Lambda-funktioner (Java 8+) är koncisa anonyma funktioner, och ett funktionellt gränssnitt är ett gränssnitt med exakt en abstrakt metod — måltypen som lambdan implementerar. Tillsammans förde de funktionell programmering till Java och driver Stream API.
{
;
}
Ett gränssnitt med en abstrakt metod är "funktionellt" — en lambda kan implementera det eftersom det inte finns någon tvetydighet om vilken metod lambdan representerar.
// ❌ 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
Lambdan (a, b) -> a + b tillhandahåller implementeringen av den enda metoden — ingen klass, ingen boilerplate för metodsignatur.
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 tillhandahåller färdiggjorda funktionella gränssnitt för vanliga mönster, använda i hela standardbiblioteket (särskilt 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
Lambda-funktioner och funktionella gränssnitt förde funktionell programmering till Java och förändrade fundamentalt hur moderna Java skrivs.
De eliminerar den verbose anonymous-class-boilerplaten för att skicka beteende som data, vilket möjliggör koncisa händelsehanterare, jämförare, återanrop och — viktigast av allt — hela Stream API (som beror på lambdor för sina filter/map/reduce-operationer).
Att förstå att en lambda riktar sig mot ett funktionellt gränssnitt (en abstrakt metod), de inbyggda gränssnitten (Function, Predicate, Consumer, Supplier) och metodreferenser är väsentligt för att skriva idiomatisk modern Java och använda streams, collections och concurrent API:er effektivt.
De representerar en större utveckling av språket och är centrala för nuvarande Java-kompetens.