Lambdas (Java 8+) sind prägnante anonyme Funktionen, und eine funktionale Schnittstelle ist eine Schnittstelle mit genau einer abstrakten Methode — der Zieltyp, den ein Lambda implementiert. Zusammen brachten sie funktionale Programmierung zu Java und treiben die Stream API an.
{
;
}
Eine Schnittstelle mit einer abstrakten Methode ist "funktional" — ein Lambda kann sie implementieren, da es keine Mehrdeutigkeit darüber gibt, welche Methode das Lambda darstellt.
// ❌ 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
Das Lambda (a, b) -> a + b stellt die Implementierung der einzelnen Methode bereit — keine Klasse, keine Methodensignatur-Boilerplate.
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 stellt vorgefertigte funktionale Schnittstellen für gängige Formen zur Verfügung, die in der gesamten Standardbibliothek verwendet werden (besonders in Streams).
// 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
Lambdas und funktionale Schnittstellen brachten funktionale Programmierung zu Java und veränderten grundlegend, wie modernes Java geschrieben wird.
Sie beseitigen die ausführliche Boilerplate von anonymen Klassen, um Verhalten als Daten zu übergeben, und ermöglichen prägnante Ereignishandler, Komparatoren, Rückrufe und — am wichtigsten — die gesamte Stream API (die für ihre filter/map/reduce-Operationen auf Lambdas angewiesen ist).
Das Verständnis, dass ein Lambda auf eine funktionale Schnittstelle abzielt (eine abstrakte Methode), die integrierten Schnittstellen (Function, Predicate, Consumer, Supplier) und Methodenreferenzen sind für das Schreiben von idiomatischem modernem Java und die effektive Nutzung von Streams, Sammlungen und gleichzeitigen APIs erforderlich.
Sie stellen eine große Sprachentwicklung dar und sind Kern der aktuellen Java-Sprachkompetenz.