Lambdas (Java 8+) er koncise anonyme funktioner, og et funktionelt interface er et interface med præcis én abstrakt metode — måltypen, som en lambda implementerer. Sammen bragte de funktionel programmering til Java og driver Stream API.
{
;
}
Et interface med én abstrakt metode er "funktionelt" — en lambda kan implementere det, fordi der ikke er nogen tvetydighed om, hvilken metode lambdaen repræsenterer.
// ❌ 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
Lambdaen (a, b) -> a + b giver implementeringen af den eneste metode — ingen klasse, ingen metodesignatur-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 leverer færdiglavede funktionelle interfaces til almindelige former, der bruges i hele standardbiblioteket (især 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 og funktionelle interfaces bragte funktionel programmering til Java og ændrede fundamentalt, hvordan moderne Java skrives.
De eliminerer det omstændeligt anonyme klassebeskadigelse for at videregive adfærd som data, hvilket muliggør kortfattede begivenhedshåndtere, komparatorer, tilbagekald og — vigtigst af alt — hele Stream API (som afhænger af lambdas for sine filter/map/reduce-operationer).
Forståelse af, at en lambda målretter et funktionelt interface (én abstrakt metode), de indbyggede interfaces (Function, Predicate, Consumer, Supplier) og metodereferences er vigtig for at skrive idiomatisk moderne Java og bruge streams, samlinger og samtidige API'er effektivt.
De repræsenterer en større udvikling af sproget og er centrale for nuværende Java-flydende tale.