Espressioni Lambda

A partire da Java 8, è stato introdotto il supporto alla programmazione funzionale grazie alle Espressioni Lambda. Una lambda è essenzialmente un metodo anonimo (una funzione senza nome) che può essere passata come argomento a metodi o memorizzata in variabili.

Le Interfacce Funzionali

Un'espressione lambda può essere usata solo dove è richiesta un'Interfaccia Funzionale (Functional Interface). Si tratta di un'interfaccia che dichiara un solo metodo astratto. Java contrassegna queste interfacce con l'annotazione opzionale @FunctionalInterface.

Esempio di interfaccia funzionale definita dall'utente:

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

Prima di Java 8, avremmo dovuto definire una classe anonima. Con le lambda, la sintassi si riduce a:

MathOperation addition = (a, b) -> a + b;
int result = addition.operate(5, 3); // Ritorna 8

Struttura delle Espressioni Lambda

La sintassi di base di una lambda è:

(parametri) -> { corpo }

• Senza parametri: () -> System.out.println("Hello")
• Singolo parametro: x -> x * 2 (le parentesi tonde possono essere omesse)
• Più parametri: (x, y) -> x + y
• Corpo multi-linea: se il corpo contiene più istruzioni, servono le parentesi graffe {} e l'istruzione return esplicita.

MathOperation detailedAddition = (a, b) -> {
    System.out.println("Somma in corso...");
    return a + b;
};

Interfacce Funzionali Standard in Java

Il pacchetto java.util.function fornisce molte interfacce funzionali predefinite:

• Predicate<T>: accetta un argomento di tipo T e restituisce un booleano (metodo test(T t)).
• Consumer<T>: accetta un argomento di tipo T ed esegue un'operazione senza ritornare nulla (metodo accept(T t)).
• Function<T, R>: accetta un argomento T e restituisce un risultato R (metodo apply(T t)).
• Supplier<T>: non accetta argomenti e restituisce un valore T (metodo get()).

Prova tu