Les lambdas (Java 8+) sont des fonctions anonymes concises, et une interface fonctionnelle est une interface avec exactement une méthode abstraite — le type cible qu'une lambda implémente. Ensemble, elles ont apporté la programmation fonctionnelle à Java et alimentent l'API Stream.
{
;
}
Une interface avec une seule méthode abstraite est « fonctionnelle » — une lambda peut l'implémenter car il n'y a aucune ambiguïté sur la méthode que la lambda représente.
// ❌ 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
La lambda (a, b) -> a + b fournit l'implémentation de la seule méthode — pas de classe, pas de boilerplate de signature de méthode.
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 fournit des interfaces fonctionnelles prêtes à l'emploi pour les formes courantes, utilisées dans toute la bibliothèque standard (en particulier les 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
Les lambdas et les interfaces fonctionnelles ont apporté la programmation fonctionnelle à Java, changeant fondamentalement la façon dont Java moderne est écrit.
Elles éliminent le boilerplate verbeux des classes anonymes pour transmettre le comportement comme données, permettant des gestionnaires d'événements concis, des comparateurs, des callbacks, et — surtout — l'ensemble de l'API Stream (qui dépend des lambdas pour ses opérations filter/map/reduce).
Comprendre qu'une lambda cible une interface fonctionnelle (une méthode abstraite), les interfaces intégrées (Function, Predicate, Consumer, Supplier), et les références de méthode est essentiel pour écrire du Java moderne idiomatique et utiliser efficacement les streams, collections, et APIs concurrentes.
Elles représentent une évolution majeure du langage et sont essentielles à la maîtrise actuelle de Java.
Une bibliothèque de questions d'entretien IT avec des réponses détaillées — du Junior au Senior.
Faire un don