Expressions Lambda

À partir de Java 8, le support de la programmation fonctionnelle a été introduit grâce aux Expressions Lambda. Une lambda est essentiellement une méthode anonyme (une fonction sans nom) qui peut être passée comme argument à des méthodes ou stockée dans des variables.

Les Interfaces Fonctionnelles

Une expression lambda ne peut être utilisée que là où une Interface Fonctionnelle (Functional Interface) est requise. Il s'agit d'une interface qui déclare une seule méthode abstraite. Java marque ces interfaces avec l'annotation optionnelle @FunctionalInterface.

Exemple d'interface fonctionnelle définie par l'utilisateur :

@FunctionalInterface
interface MathOperation {
    int operate(int a, int b);
}

Avant Java 8, nous aurions dû définir une classe anonyme. Avec les lambdas, la syntaxe est réduite à :

MathOperation addition = (a, b) -> a + b;
int result = addition.operate(5, 3); // Ritorna 8

Structure des Expressions Lambda

La syntaxe de base d'une lambda est :

(parametri) -> { corpo }

• Sans paramètres : () -> System.out.println("Hello")
• Paramètre unique : x -> x * 2 (les parenthèses peuvent être omises)
• Plusieurs paramètres : (x, y) -> x + y
• Corps multi-lignes : si le corps contient plusieurs instructions, les accolades {} et l'instruction return explicite sont nécessaires.

MathOperation detailedAddition = (a, b) -> {
    System.out.println("Somma in corso...");
    return a + b;
};

Interfaces Fonctionnelles Standards en Java

Le paquet java.util.function fournit de nombreuses interfaces fonctionnelles prédéfinies :

• Predicate<T> : accepte un argument de type T et renvoie un booléen (méthode test(T t)).
• Consumer<T> : accepte un argument de type T et effectue une opération sans rien renvoyer (méthode accept(T t)).
• Function<T, R> : accepte un argument T et renvoie un résultat R (metodo apply(T t)).
• Supplier<T> : n'accepte aucun argument et renvoie une valeur T (méthode get()).

À toi de jouer