Programmation fonctionnelle en Java : des lambdas au Stream API

Introduction à la programmation fonctionnelle en Java

Pendant longtemps, Java a été exclusivement associé à la programmation orientée objet (POO). Cependant, avec la sortie de Java 8 en 2014, le langage a fait un bond puissant vers le paradigme fonctionnel. Les expressions lambda, les interfaces fonctionnelles et le Stream API ont radicalement changé l'approche de l'écriture de code, le rendant plus concis, plus lisible et moins sujet aux erreurs.

La programmation fonctionnelle en Java n'est pas un remplacement de la POO, mais un complément puissant. Elle permet d'écrire du code déclaratif, où vous décrivez ce qui doit être fait, et non comment. Dans cet article, nous allons décomposer les concepts clés qui vous aideront à maîtriser le style fonctionnel en Java, et montrer des exemples pratiques.

1. Expressions lambda et interfaces fonctionnelles

La base de la programmation fonctionnelle en Java repose sur les expressions lambda — c'est une manière compacte d'implémenter des fonctions anonymes. Syntaxiquement, une lambda se compose d'une liste de paramètres, d'une flèche (->) et d'un corps :

(paramètres) -> { corps }

Les lambdas fonctionnent toujours en tandem avec les interfaces fonctionnelles. Une interface fonctionnelle est une interface qui contient exactement une méthode abstraite (par exemple, Runnable, Comparator, Predicate).

Exemple pratique : remplacement d'une classe anonyme

Considérons la comparaison entre l'ancienne approche (POO) et la nouvelle (fonctionnelle) :

// Ancienne méthode (classe anonyme)Runnable taskOld = new Runnable() {    @Override    public void run() {        System.out.println("Bonjour depuis une classe anonyme !");    }};

// Nouvelle méthode (lambda)Runnable taskNew = () -> System.out.println("Bonjour depuis une lambda !");

// ExécutiontaskNew.run();

Comme vous pouvez le voir, la lambda a réduit le code de 6 lignes à 1, tout en conservant la fonctionnalité complète.

Interfaces fonctionnelles intégrées (package java.util.function)

Java fournit un riche ensemble d'interfaces intégrées. Voici les quatre principales :

• Predicate<T> — prend un objet, retourne un boolean. Utilisé pour le filtrage.
• Function<T, R> — prend un objet d'un type, retourne un objet d'un autre type. Pour les transformations.
• Consumer<T> — prend un objet, ne retourne rien (void). Pour les effets secondaires (affichage).
• Supplier<T> — ne prend rien, retourne un objet. Pour la génération paresseuse de données.

Exemple avec Predicate :

import java.util.function.Predicate;

public class Main {    public static void main(String[] args) {        Predicate<Integer> isEven = n -> n % 2 == 0;        System.out.println(isEven.test(10)); // true        System.out.println(isEven.test(7));  // false    }}

2. Stream API : travailler avec les collections en style fonctionnel

Le Stream API est le joyau de la programmation fonctionnelle en Java. Un flux (Stream) est une séquence d'éléments supportant des opérations séquentielles et parallèles. Le principal avantage : vous ne modifiez pas les données sources, mais créez un nouveau résultat.

Le Stream API repose sur trois étapes :

1. Création du flux (à partir d'une collection, d'un tableau ou d'un générateur).
2. Opérations intermédiaires (filtrage, tri, transformation). Retournent un nouveau Stream.
3. Opération terminale (collecte du résultat, comptage, recherche). Termine le travail du flux.

Exemple : filtrage et transformation d'une liste

Supposons que nous ayons une liste de chaînes de caractères, et que nous voulions obtenir uniquement celles qui ont plus de 3 caractères, les convertir en majuscules et les trier.

import java.u