Java - Expressions Lambda

Salut à tous, futurs magiciens de Java ! Aujourd'hui, nous allons entreprendre un voyage passionnant dans le monde des Expressions Lambda. Ne vous inquiétez pas si vous êtes nouveau dans la programmation - je vais vous guider à travers ce concept étape par étape, comme j'ai fait pour des centaines d'étudiants au cours de mes années d'enseignement. Alors, prenez une tasse de café (ou de thé, si c'est votre truc), et plongons dedans !

Quelles sont les Expressions Lambda ?

Imaginez que vous êtes à une fête et que vous voulez raconter une blague à vos amis. Plutôt que d'écrire toute la blague et de faire circuler le papier, ne serait-il pas plus simple de le dire à voix haute ? C'est essentiellement ce que font les Expressions Lambda en Java - elles fournissent une manière rapide et concise d'exprimer des instances d'interfaces à méthode unique (interfaces fonctionnelles).

Les Expressions Lambda ont été introduites en Java 8 pour apporter certains avantages de la programmation fonctionnelle à Java. Elles rendent votre code plus lisible, concis et parfois plus efficace.

Syntaxe de l'Expression Lambda

La syntaxe de base d'une Expression Lambda ressemble à ceci :

(parameters) -> { body }

C'est comme une mini-fonction sans nom. Décomposons-la :

• parameters : Ce sont les paramètres d'entrée (si il y en a)
• -> : Cette flèche est utilisée pour séparer les paramètres du corps
• body : Cela contient le code à exécuter

Caractéristiques des Expressions Lambda en Java

1. Inférence de type : Java peut souvent deviner le type des paramètres, donc vous n'avez pas toujours besoin de les spécifier.
2. Unique expression : Si le corps contient une seule expression, vous pouvez omettre les accolades.
3. Multiple paramètres : Vous pouvez avoir zéro, un ou plusieurs paramètres.
4. Instruction return : Si le corps contient une seule expression, l'instruction return est optionnelle.

Exemples d'Expressions Lambda en Java

Voyons quelques exemples pour voir comment les Expressions Lambda fonctionnent dans la pratique.

Exemple 1 : Expression Lambda Simple

// Façon traditionnelle
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("Bonjour, le monde !");
}
};

// Façon Lambda
Runnable lambdaRunnable = () -> System.out.println("Bonjour, monde Lambda !");

// Exécution des deux
runnable.run();
lambdaRunnable.run();

Dans cet exemple, nous créons un objet Runnable. La méthode traditionnelle nécessite la création d'une classe anonyme interne, tandis que la méthode Lambda est beaucoup plus concise. Les deux afficheront un message lorsque họ seront exécutés.

Exemple 2 : Lambda avec des Paramètres

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

public class LambdaExample {
public static void main(String[] args) {
MathOperation addition = (a, b) -> a + b;
MathOperation subtraction = (a, b) -> a - b;

System.out.println("10 + 5 = " + addition.operate(10, 5));
System.out.println("10 - 5 = " + subtraction.operate(10, 5));
}
}

Ici, nous définissons une interface fonctionnelle MathOperation et utilisons des Expressions Lambda pour implémenter les opérations d'addition et de soustraction. Notez à quel point le code devient propre et lisible !

Portée des Expressions Lambda en Java

Les Expressions Lambda ont la même portée que les classes internes. Elles peuvent capturer des variables de la portée englobante, mais ces variables doivent être effectivement finales (leur valeur ne change pas après l'initialisation).

public class ScopeExample {
public static void main(String[] args) {
int multiplier = 2;
IntUnaryOperator doubler = (n) -> n * multiplier;
System.out.println(doubler.applyAsInt(4)); // Outputs: 8

// Cela causerait une erreur :
// multiplier = 3;
}
}

Dans cet exemple, multiplier est effectivement final et peut être utilisé dans l'Expression Lambda.

Utilisation de Constantes dans les Expressions Lambda

Les constantes peuvent être utilisées librement dans les Expressions Lambda. C'est une excellente manière de rendre vos Expressions Lambda plus flexibles et réutilisables.

public class ConstantExample {
private static final int MAGIC_NUMBER = 42;

public static void main(String[] args) {
IntSupplier magicSupplier = () -> MAGIC_NUMBER;
System.out.println("Le nombre magique est : " + magicSupplier.getAsInt());
}
}

Ici, nous utilisons une constante MAGIC_NUMBER dans notre Expression Lambda. Cela est tout à fait correct et ne viole aucune règle de portée.

Utilisation des Expressions Lambda dans les Collections

Les Expressions Lambda brillent vraiment lorsqu'elles sont utilisées avec des collections. Elles peuvent rendre votre code beaucoup plus lisible et concis. Voici quelques exemples :

Trier une Liste

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// Façon traditionnelle
Collections.sort(names, new Comparator<String>() {
@Override
public int compare(String a, String b) {
return b.compareTo(a);
}
});

// Façon Lambda
names.sort((a, b) -> b.compareTo(a));

System.out.println(names); // Outputs: [David, Charlie, Bob, Alice]

Itérer à travers une Liste

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// Façon traditionnelle
for (Integer number : numbers) {
System.out.println(number);
}

// Façon Lambda
numbers.forEach(number -> System.out.println(number));

// Ou encore plus concis
numbers.forEach(System.out::println);

Filtrer une Liste

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// Obtenir les nombres pairs
List<Integer> evenNumbers = numbers.stream()
.filter(n -> n % 2 == 0)
.collect(Collectors.toList());

System.out.println(evenNumbers); // Outputs: [2, 4, 6, 8, 10]

Dans ce dernier exemple, nous utilisons l'API Stream ainsi qu'une Expression Lambda pour filtrer les nombres pairs de notre liste. La méthode filter prend un Predicate (une fonction qui renvoie un booléen), que nous fournissons à l'aide d'une Expression Lambda.

Conclusion

Et voilà, les amis ! Nous avons fait le voyage à travers le pays des Expressions Lambda, de leur syntaxe de base à leurs applications pratiques dans les collections. Souvenez-vous, les Expressions Lambda sont comme le sel dans la cuisine - utilisez-les intelligemment, et elles peuvent rendre votre code beaucoup plus savoureux (et par savoureux, je veux dire lisible et efficace) !

Comme pour tout nouveau concept, la clé pour maîtriser les Expressions Lambda est la pratique. Alors, allez-y et lambda-isez votre code ! Et souvenez-vous, même si vous rencontrez des erreurs en cours de route, cela fait partie du processus d'apprentissage. Comme je le dis toujours à mes étudiants, en programmation, les erreurs ne sont que des opportunités de croissance déguisées.

Continuez à coder, continuez à apprendre, et surtout, amusez-vous avec ça ! Jusqu'à la prochaine fois, c'est votre enseignant de Java du coin qui vous dit aurevoir. Bonne programmation !

Credits: Image by storyset