Que sont les lambdas et les interfaces fonctionnelles ?

Question

Accepted Answer

**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 fonctionnelle ```java @FunctionalInterface // optional annotation — enforces ONE abstract method interface Calculator { int calculate(int a, int b); // the single abstract method } ``` 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. ## Syntaxe lambda — implémentez-la de manière concise ```java // ❌ 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. ## Interfaces fonctionnelles intégrées (java.util.function) ```java Function length = s -> s.length(); // takes T, returns R Predicate isPositive = n -> n > 0; // takes T, returns boolean Consumer printer = s -> System.out.println(s); // takes T, returns void Supplier greeting = () -> "Hello"; // takes nothing, returns T BiFunction 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). ## Références de méthode — encore plus court ```java // 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 ``` ## Où les lambdas brillent ```java // 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 ``` ## Pourquoi c'est important 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.