Lambdas (Java 8+) zijn beknopte anonieme functies, en een functional interface is een interface met precies één abstracte methode — het doeltype dat een lambda implementeert. Samen brachten zij functioneel programmeren naar Java en geven zij kracht aan de Stream API.
{
;
}
Een interface met één abstracte methode is "functioneel" — een lambda kan het implementeren omdat er geen dubbelzinnigheid is over welke methode de lambda vertegenwoordigt.
// ❌ 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
De lambda (a, b) -> a + b biedt de implementatie van de enkele methode — geen klasse, geen methodesignatuur 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 biedt kant-en-klare functional interfaces voor veelvoorkomende vormen, gebruikt in de hele standaardbibliotheek (vooral 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 en functional interfaces brachten functioneel programmeren naar Java en hebben fundamenteel veranderd hoe modern Java wordt geschreven.
Zij elimineren de uitgebreide boilerplate van anonieme klassen voor het doorgeven van gedrag als gegevens, waardoor event handlers, vergelijkers, callbacks beknopt kunnen worden, en — nog belangrijker — de gehele Stream API (die afhankelijk is van lambdas voor de filter/map/reduce-bewerkingen).
Het begrijpen dat een lambda gericht is op een functional interface (één abstracte methode), de ingebouwde interfaces (Function, Predicate, Consumer, Supplier), en methodeverwijzingen is essentieel voor het schrijven van idiomatische moderne Java en het effectief gebruiken van streams, collections en concurrent APIs.
Zij vertegenwoordigen een grote evolutie van de taal en zijn kernonderdeel van huidige Java-vlotheid.