11.2.2 – Cas d'usage courants

Les lambdas sont particulièrement utiles avec les collections, les streams, les threads, et bien d'autres cas d'usage. Voici tous les cas possibles :

🔄 Avec les collections

1. forEach - Parcourir une collection

Exemple : forEach avec List

import java.util.ArrayList;
import java.util.List;

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");
list.add("Charlie");

// Parcourir avec lambda
list.forEach(n -> System.out.println(n));

// Avec référence de méthode
list.forEach(System.out::println);

// Avec plusieurs instructions
list.forEach(n -> {
    System.out.println("Nom : " + n);
    System.out.println("Longueur : " + n.length());
});

2. removeIf - Supprimer des éléments

Exemple : removeIf avec Predicate

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");
list.add("Charlie");

// Supprimer les éléments qui commencent par "A"
list.removeIf(s -> s.startsWith("A"));

// Supprimer les éléments de longueur > 4
list.removeIf(s -> s.length() > 4);

3. replaceAll - Remplacer tous les éléments

Exemple : replaceAll

List<String> list = new ArrayList<>();
list.add("alice");
list.add("bob");

// Mettre en majuscules
list.replaceAll(s -> s.toUpperCase());

// Ajouter un préfixe
list.replaceAll(s -> "Nom: " + s);

4. sort - Trier avec Comparator

Exemple : sort avec lambda

List<String> list = new ArrayList<>();
list.add("Charlie");
list.add("Alice");
list.add("Bob");

// Trier par ordre alphabétique
list.sort((s1, s2) -> s1.compareTo(s2));

// Trier par longueur
list.sort((s1, s2) -> s1.length() - s2.length());

// Trier inversé
list.sort((s1, s2) -> s2.compareTo(s1));

🌊 Avec les streams

1. filter - Filtrer les éléments

Exemple : filter avec Predicate

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

List<Integer> nombres = Arrays.asList(1, 2, 3, 4, 5, 10, 15, 20);

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

// Filtrer les nombres > 10
List<Integer> grands = nombres.stream()
    .filter(n -> n > 10)
    .collect(Collectors.toList());

// Filtrer avec condition complexe
List<Integer> resultat = nombres.stream()
    .filter(n -> n > 5 && n < 15)
    .collect(Collectors.toList());

2. map - Transformer les éléments

Exemple : map avec Function

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

// Calculer les carrés
List<Integer> carres = nombres.stream()
    .map(n -> n * n)
    .collect(Collectors.toList());

// Transformer en String
List<String> chaines = nombres.stream()
    .map(n -> "Nombre: " + n)
    .collect(Collectors.toList());

// Transformer avec opération complexe
List<Integer> doubles = nombres.stream()
    .map(n -> {
        int resultat = n * 2;
        return resultat + 1;
    })
    .collect(Collectors.toList());

3. forEach - Parcourir un stream

Exemple : forEach sur stream

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

// Afficher chaque élément
list.stream().forEach(s -> System.out.println(s));

// Avec traitement
list.stream().forEach(s -> {
    String maj = s.toUpperCase();
    System.out.println("Nom en majuscules : " + maj);
});

4. reduce - Réduire à une valeur

Exemple : reduce

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

// Somme
int somme = nombres.stream()
    .reduce(0, (a, b) -> a + b);

// Produit
int produit = nombres.stream()
    .reduce(1, (a, b) -> a * b);

// Maximum
int max = nombres.stream()
    .reduce(Integer.MIN_VALUE, (a, b) -> a > b ? a : b);

5. allMatch, anyMatch, noneMatch - Tests conditionnels

Exemple : Tests avec Predicate

List<Integer> nombres = Arrays.asList(2, 4, 6, 8);

// Tous pairs ?
boolean tousPairs = nombres.stream()
    .allMatch(n -> n % 2 == 0);  // true

// Au moins un > 10 ?
boolean auMoinsUn = nombres.stream()
    .anyMatch(n -> n > 10);  // false

// Aucun négatif ?
boolean aucunNegatif = nombres.stream()
    .noneMatch(n -> n < 0);  // true

6. findFirst, findAny - Trouver un élément

Exemple : findFirst et findAny

import java.util.Optional;

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

// Trouver le premier > 5
Optional<Integer> premier = nombres.stream()
    .filter(n -> n > 5)
    .findFirst();

premier.ifPresent(n -> System.out.println("Premier : " + n));

// Trouver n'importe quel élément pair
Optional<Integer> pair = nombres.stream()
    .filter(n -> n % 2 == 0)
    .findAny();

🧵 Avec les threads

Exemple : Threads avec lambda

// Thread simple
Thread t1 = new Thread(() -> System.out.println("Thread 1"));
t1.start();

// Thread avec plusieurs instructions
Thread t2 = new Thread(() -> {
    for (int i = 0; i < 5; i++) {
        System.out.println("Thread 2 : " + i);
    }
});
t2.start();

// ExecutorService avec lambda
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ExecutorService executor = Executors.newFixedThreadPool(3);
executor.submit(() -> System.out.println("Tâche exécutée"));
executor.shutdown();

🎯 Références de méthodes

Les références de méthodes sont une syntaxe encore plus concise que les lambdas dans certains cas.

1. Référence à une méthode statique

Exemple : Référence à méthode statique

import java.util.function.Function;

// Lambda
Function<String, Integer> f1 = s -> Integer.parseInt(s);

// Référence de méthode
Function<String, Integer> f2 = Integer::parseInt;

// Utilisation
int nombre = f2.apply("123");

2. Référence à une méthode d'instance

Exemple : Référence à méthode d'instance

List<String> list = Arrays.asList("alice", "bob");

// Lambda
list.forEach(s -> System.out.println(s));

// Référence de méthode
list.forEach(System.out::println);

// Méthode sur l'objet
list.forEach(String::toUpperCase);  // Appelle toUpperCase() sur chaque élément

3. Référence à un constructeur

Exemple : Référence à constructeur

import java.util.function.Supplier;

// Lambda
Supplier<StringBuilder> s1 = () -> new StringBuilder();

// Référence de méthode
Supplier<StringBuilder> s2 = StringBuilder::new;

// Avec Function
Function<String, StringBuilder> f = StringBuilder::new;
StringBuilder sb = f.apply("Hello");

🔗 Lambdas avec variables locales

Exemple : Accès aux variables locales

// Variable final ou effectivement final
final int multiplicateur = 10;

List<Integer> nombres = Arrays.asList(1, 2, 3);

// Lambda peut accéder à multiplicateur
List<Integer> resultats = nombres.stream()
    .map(n -> n * multiplicateur)
    .collect(Collectors.toList());

// Variable effectivement final (pas modifiée après)
int facteur = 5;
List<Integer> resultats2 = nombres.stream()
    .map(n -> n * facteur)  // OK : facteur est effectivement final
    .collect(Collectors.toList());

// ❌ ERREUR : variable modifiée
int compteur = 0;
// nombres.forEach(n -> compteur++);  // Erreur : compteur n'est pas final

📊 Tableau récapitulatif des interfaces fonctionnelles

💡 Points clés à retenir

• Syntaxe : (paramètres) -> expression ou (paramètres) -> { bloc }
• Interfaces fonctionnelles : Une seule méthode abstraite
• Collections : forEach, removeIf, replaceAll, sort
• Streams : filter, map, reduce, forEach, allMatch, anyMatch, findFirst
• Threads : Runnable avec lambda
• Références de méthodes : Syntaxe encore plus concise (::)
• Variables locales : Doivent être final ou effectivement final
• Types inférés : Le compilateur déduit automatiquement les types