Java Academy · Lezione

Function e BiFunction

Trasformare i valori in modo funzionale

Function e BiFunction è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Cosa rappresenta Function

Function<T, R> è l'interfaccia fondamentale per le trasformazioni in java.util.function. Accetta un argomento di tipo T e restituisce un risultato di tipo R.

Il suo unico metodo astratto è R apply(T t).
Rappresenta una trasformazione pura dall'input all'output.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, Integer> length = s -> s.length();
        System.out.println(length.apply("hello"));
    }
}

Chiamare apply

Si invoca una Function chiamando apply. Il corpo della lambda contiene la logica della trasformazione.

I tipi dell'input e dell'output possono essere diversi.
Un riferimento a metodo come String::toUpperCase può sostituire una lambda.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> upper = String::toUpperCase;
        System.out.println(upper.apply("java"));
    }
}

Composizione con andThen

andThen concatena le funzioni: il risultato della prima diventa l'input della seconda.

f.andThen(g) significa g(f(x)).
La lettura procede da sinistra a destra.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.andThen(plus3).apply(5));
    }
}

Composizione con compose

compose esegue prima la funzione ricevuta come argomento.

f.compose(g) significa f(g(x)).
È l'immagine speculare di andThen.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> times2 = n -> n * 2;
        Function<Integer, Integer> plus3 = n -> n + 3;
        System.out.println(times2.compose(plus3).apply(5));
    }
}

Function.identity

Function.identity() restituisce una funzione che restituisce l'input senza modificarlo.

È utile nei collector degli stream e nelle associazioni predefinite.
È equivalente a x -> x.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> id = Function.identity();
        System.out.println(id.apply("unchanged"));
    }
}

Conoscere BiFunction

BiFunction<T, U, R> accetta due argomenti e restituisce un risultato.

Il suo metodo è R apply(T t, U u).
È ideale per combinare due valori, ad esempio per unire mappe.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        System.out.println(add.apply(4, 6));
    }
}

BiFunction con tipi diversi

I tre parametri di tipo di BiFunction possono essere tutti diversi.

Qui si combinano una String e un int per ottenere una String.

import java.util.function.BiFunction;

public class Main {
    public static void main(String[] args) {
        BiFunction<String, Integer, String> repeat = (s, n) -> s.repeat(n);
        System.out.println(repeat.apply("ab", 3));
    }
}

BiFunction e andThen

BiFunction supporta anche andThen, che accetta una Function con un solo argomento per elaborare ulteriormente il risultato.

BiFunction non dispone di compose perché avrebbe bisogno di due input.

import java.util.function.BiFunction;
import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        BiFunction<Integer, Integer, Integer> add = (a, b) -> a + b;
        Function<Integer, String> label = n -> "sum=" + n;
        System.out.println(add.andThen(label).apply(7, 8));
    }
}

Le funzioni nelle collection

Molte API accettano una Function. Ad esempio, Map.computeIfAbsent accetta una funzione di mapping per le chiavi mancanti.

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> lengths = new HashMap<>();
        lengths.computeIfAbsent("hello", String::length);
        System.out.println(lengths);
    }
}

Memorizzare le funzioni nelle variabili

Poiché le funzioni sono oggetti, è possibile memorizzarle, passarle e restituirle. Questa è la base dello stile funzionale in Java.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<Integer, Integer> square = n -> n * n;
        Function<Integer, Integer> cube = n -> n * n * n;
        Function<Integer, Integer> chosen = square;
        System.out.println(chosen.apply(5));
    }
}

Costruire una pipeline

La concatenazione ripetuta di andThen costruisce una pipeline di trasformazioni leggibile e riutilizzabile.

import java.util.function.Function;

public class Main {
    public static void main(String[] args) {
        Function<String, String> trim = String::trim;
        Function<String, String> upper = String::toUpperCase;
        Function<String, Integer> len = String::length;
        System.out.println(trim.andThen(upper).andThen(len).apply("  abc "));
    }
}

Verifica rapida

Che cosa calcola f.andThen(g).apply(x)?

Riepilogo

Ha imparato le interfacce fondamentali per le trasformazioni:

Function<T,R> trasforma un valore con apply.
andThen concatena in avanti (g(f(x))); compose concatena all'indietro (f(g(x))).
Function.identity() restituisce il proprio input.
BiFunction<T,U,R> gestisce due input e supporta andThen, ma non compose.

Domande Frequenti

La lezione «Function e BiFunction» è gratuita?

Sì — il testo completo di «Function e BiFunction» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Function e BiFunction»?

Trasformare i valori in modo funzionale Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Function e BiFunction»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Java Academy