I lambda (Java 8+) sono funzioni anonime concise, e un'interfaccia funzionale è un'interfaccia con esattamente un metodo astratto — il tipo target che un lambda implementa. Insieme hanno portato la programmazione funzionale in Java e alimentano l'API Stream.
{
;
}
Un'interfaccia con un metodo astratto è "funzionale" — un lambda può implementarla perché non c'è ambiguità su quale metodo il lambda rappresenta.
// ❌ verbose anonymous class (pre-Java 8)
Calculator add = new Calculator() {
public int calculate(int a, int b) { return a + b; }
};
// ✅ lambda — same thing, far less boilerplate
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;
add.calculate(2, 3); // 5
Il lambda (a, b) -> a + b fornisce l'implementazione del metodo singolo — nessuna classe, nessun boilerplate di firma del metodo.
Function<String, Integer> length = s -> s.length(); // takes T, returns R
Predicate<Integer> isPositive = n -> n > 0; // takes T, returns boolean
Consumer<String> printer = s -> System.out.println(s); // takes T, returns void
Supplier<String> greeting = () -> "Hello"; // takes nothing, returns T
BiFunction<Integer, Integer, Integer> sum = (a, b) -> a + b; // two args
Java fornisce interfacce funzionali già pronte per forme comuni, utilizzate in tutta la libreria standard (specialmente gli stream).
// when a lambda just calls an existing method, use a method reference
list.forEach(System.out::println); // instead of x -> System.out.println(x)
list.stream().map(String::toUpperCase); // instead of s -> s.toUpperCase()
list.stream().map(Integer::parseInt); // static method ref
// passing behavior as arguments — the core enabler of the Stream API
people.stream()
.filter(p -> p.getAge() > 18) // Predicate lambda
.map(Person::getName) // method reference
.forEach(System.out::println); // Consumer
list.sort((a, b) -> a.compareTo(b)); // Comparator lambda
button.addActionListener(e -> handleClick()); // event handler
I lambda e le interfacce funzionali hanno portato la programmazione funzionale in Java, cambiando fondamentalmente il modo in cui il moderno Java viene scritto.
Eliminano il verbose boilerplate della classe anonima per passare il comportamento come dati, abilitando gestori di eventi concisi, comparatori, callback e — soprattutto — l'intera API Stream (che dipende dai lambda per le operazioni filter/map/reduce).
Comprendere che un lambda mira a un'interfaccia funzionale (un metodo astratto), le interfacce predefinite (Function, Predicate, Consumer, Supplier) e i riferimenti ai metodi è essenziale per scrivere Java moderno idiomatico e utilizzare stream, collezioni e API concorrenti in modo efficace.
Rappresentano un'evoluzione importante del linguaggio e sono fondamentali per l'attuale conoscenza fluente di Java.