Parlez du concept de la classe CompletableFuture…

CompletableFuture est une classe en Java 8+ qui implémente les interfaces Future et CompletionStage. Elle représente un calcul asynchrone qui peut être complété (ou échoué) à un moment donné dans le futur, et sur lequel on peut effectuer des actions ultérieures de manière déclarative, sans bloquer le fil principal.

Les principales fonctionnalités :

Exécution asynchrone : Permet de lancer des tâches dans un fil séparé (ou un pool de fils).
Composition : Il est possible de combiner plusieurs CompletableFuture, créant des chaînes d'actions dépendantes.
Gestion des exceptions : Fournit des méthodes pour gérer les erreurs dans les calculs asynchrones.
Opérations non bloquantes : Le résultat ou l'exception sont traités lorsque le future se termine, sans attente explicite (get()).

Méthodes clés :

Création :
- supplyAsync(Supplier<T> supplier): Lance un Supplier de manière asynchrone et retourne un CompletableFuture avec son résultat.
- runAsync(Runnable runnable): Lance un Runnable de manière asynchrone et retourne un CompletableFuture<Void>.
- completedFuture(T value): Crée un CompletableFuture déjà terminé avec une valeur donnée.
Transformation :
- thenApply(Function<T, U> fn): Applique une fonction lorsque le future se termine.
- thenAccept(Consumer<T> action): Effectue une action sur le résultat lorsque le future se termine.
- thenRun(Runnable action): Effectue une action lorsque le future se termine, en ignorant le résultat.
- thenCompose(Function<T, CompletionStage<U>> fn): Permet de construire des chaînes où le résultat d'un future est utilisé pour créer un autre.
Combinaison :
- thenCombine(CompletionStage<U> other, BiFunction<T, U, V> fn): Combine les résultats de deux futures.
- allOf(CompletableFuture<?>... cfs): Retourne un CompletableFuture<Void> qui se termine lorsque tous les futures passés se terminent.
- anyOf(CompletableFuture<?>... cfs): Retourne un CompletableFuture<Object> qui se termine lorsque l'un des futures passés se termine.
Gestion des exceptions :
- exceptionally(Function<Throwable, T> fn): Gère les exceptions en renvoyant une valeur alternative.
- handle(BiFunction<T, Throwable, U> fn): Gère à la fois le résultat et l'exception.

Exemple :

// Lancer une tâche asynchrone
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000); // Simulation d'un travail long
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    return "Résultat de l'opération asynchrone";
});

// Effectuer une action après la fin de la tâche (sans bloquer)
future.thenAccept(result -> {
    System.out.println("Résultat obtenu : " + result);
});

// Une autre action dépendant de la première
future.thenApply(String::toUpperCase)
      .thenAccept(upperCaseResult -> {
          System.out.println("Résultat en majuscules : " + upperCaseResult);
      });

// Attendre que toutes les tâches se terminent (dans des applications réelles, on évite généralement d'utiliser get/join explicitement)
// future.join();

CompletableFuture est un outil puissant pour écrire du code réactif et non bloquant en Java, simplifiant considérablement la gestion de l'asynchronie par rapport à l'interface classique Future.

Parlez du concept de la classe CompletableFuture.