Lambdas Java 8 : Introduction Rapide avec Exemples Pratiques

Si vous êtes développeur Java et souhaitez maîtriser les lambdas introduites dans Java 8, cet article explore leur syntaxe et leurs applications concrètes pour un code plus élégant et efficace.

Une expression lambda en Java est une façon concise de représenter une méthode d'une interface fonctionnelle. Elle se compose d'une liste de paramètres, d'un opérateur flèche (->) et d'un corps (expression unique ou bloc de code). Elle est idéale pour passer des implémentations d'interfaces comme arguments de méthodes.

Quelques expressions lambda simples

Voici des exemples basiques d'expressions lambda.

Lambda acceptant deux entiers x et y et renvoyant leur somme :

(int x, int y) -> x + y;

Version plus concise sans types (déduits du contexte) :

(x, y) -> x + y;

Lambda sans paramètre renvoyant une constante :

() -> 404;

Lambda sans paramètre ni retour :

() -> {};

Avec un seul paramètre, les parenthèses sont optionnelles :

x -> x + 1;

Exemple avec bloc plus complexe (type déduit du contexte) :

ligne -> {
    String[] x = pattern.split(ligne);
    return new Joueur(Integer.parseInt(x[0]),
                      x[1],
                      x[2],
                      x[3],
                      Integer.parseInt(x[4]));
};

Code propre et concis

Les lambdas rendent le code plus lisible et compact. Java 8 intègre largement leur usage dans les API standard.

Boucle sur une liste ou un ensemble

Les collections comme List, Set ou Queue implémentent Iterable, facilitant les itérations.

Déclarer une liste de noms :

List<String> names = Arrays.asList("Joe", "Jack", "James", "Albert");

Boucle traditionnelle :

for (String name : names) {
    System.out.println(name);
}

Avec lambda :

names.forEach(name -> System.out.println(name));

Ou avec référence de méthode :

names.forEach(System.out::println);

Boucle sur une Map

Une Map associe clés et valeurs. Itérer sur les entrées :

Initialiser une Map :

Map<String, Integer> map = new HashMap<>();
map.put("Atlanta, Géorgie", 110);
map.put("Austin, Texas", 115);
map.put("Baltimore, Maryland", 105);
map.put("Birmingham, Alabama", 99);
map.put("Boston, Massachusetts", 98);

Boucle traditionnelle :

for (Map.Entry<String, Integer> e : map.entrySet()) {
    System.out.println(e.getKey() + " => " + e.getValue());
}

Avec lambda :

map.forEach((k, v) -> System.out.println(k + " => " + v));

Interfaces fonctionnelles

Le type d'une lambda est une interface fonctionnelle (une seule méthode abstraite). Exemple : X x = a -> a + 1; où X est compatible.

Créer une tâche multithread

Runnable est une interface fonctionnelle pour les threads :

Runnable task = () -> System.out.println("Exécution dans un thread séparé.");
Thread thread = new Thread(task);
thread.start();

Comparaison avec Comparator

Comparator définit compare() :

Comparator<String> cmp = (x, y) -> x.compareToIgnoreCase(y);
List<String> names = Arrays.asList("Joe", "Jack", "James", "Albert");
Collections.sort(names, cmp);
names.forEach(System.out::println);
// Affiche : Albert, Jack, James, Joe

Recherche binaire :

System.out.println("search(Joe): " + Collections.binarySearch(names, "Joe", cmp));
// Affiche : 3

Max/min sur une liste :

List<Integer> temps = Arrays.asList(110, 115, 105, 99, 98, 54, 109, 84, 81, 66, 72, 135, 115, 75, 82, 90, 88);
Comparator<Integer> cmpTemp = (x, y) -> Integer.compare(x, y);
System.out.println(Collections.max(temps, cmpTemp) + "/" + Collections.min(temps, cmpTemp));
// Affiche : 135/54

Utilisation en programmation GUI

Pour les gestionnaires d'événements :

JButton button = new JButton("Click Me");
button.addActionListener(e -> System.out.println("Bouton cliqué !"));

Voilà un aperçu des lambdas Java 8. Les lambdas ont-elles simplifié votre code depuis Java 8 ? Partagez en commentaires !