Lambdas (Java 8+) são funções anônimas concisas, e uma interface funcional é uma interface com exatamente um método abstrato — o tipo alvo que uma lambda implementa. Juntas, trouxeram programação funcional para Java e potencializam a API Stream.
{
;
}
Uma interface com um método abstrato é "funcional" — uma lambda pode implementá-la porque não há ambiguidade sobre qual método a lambda representa.
// ❌ 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
A lambda (a, b) -> a + b fornece a implementação do método único — sem classe, sem boilerplate de assinatura de método.
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 fornece interfaces funcionais prontas para uso para formas comuns, utilizadas em toda a biblioteca padrão (especialmente 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 e interfaces funcionais trouxeram programação funcional para Java, mudando fundamentalmente como Java moderno é escrito.
Elas eliminam o boilerplate verboso de classes anônimas para passar comportamento como dados, permitindo manipuladores de eventos, comparadores, callbacks concisos e — mais importante — toda a API Stream (que depende de lambdas para suas operações filter/map/reduce).
Compreender que uma lambda tem como alvo uma interface funcional (um método abstrato), as interfaces integradas (Function, Predicate, Consumer, Supplier) e referências de método é essencial para escrever Java moderno idiomático e usar streams, coleções e APIs concorrentes efetivamente.
Elas representam uma grande evolução da linguagem e são essenciais para a fluência em Java atual.