Fale sobre o conceito da classe CompletableFuture…

CompletableFuture é uma classe em Java 8+ que implementa as interfaces Future e CompletionStage. Representa um cálculo assíncrono que pode ser concluído (ou falhar) em algum momento no futuro, e sobre o qual podem ser realizadas ações subsequentes de forma declarativa, sem bloquear o thread principal.

As principais funcionalidades:

Execução assíncrona: Permite iniciar tarefas em uma thread separada (ou pool de threads).
Composição: É possível combinar vários CompletableFuture, criando cadeias de ações dependentes.
Gestão de exceções: Fornece métodos para lidar com erros em cálculos assíncronos.
Operações não bloqueantes: O resultado ou exceção são tratados quando o future é concluído, sem esperar explicitamente (get()).

Métodos principais:

Criação:
- supplyAsync(Supplier<T> supplier): Executa um Supplier de forma assíncrona e retorna um CompletableFuture com seu resultado.
- runAsync(Runnable runnable): Executa um Runnable de forma assíncrona e retorna um CompletableFuture<Void>.
- completedFuture(T value): Cria um CompletableFuture já concluído com um valor dado.
Transformação:
- thenApply(Function<T, U> fn): Aplica uma função ao resultado quando o future é concluído.
- thenAccept(Consumer<T> action): Executa uma ação sobre o resultado quando o future é concluído.
- thenRun(Runnable action): Executa uma ação quando o future é concluído, ignorando o resultado.
- thenCompose(Function<T, CompletionStage<U>> fn): Permite construir cadeias onde o resultado de um future é usado para criar outro.
Combinação:
- thenCombine(CompletionStage<U> other, BiFunction<T, U, V> fn): Combina os resultados de dois futures.
- allOf(CompletableFuture<?>... cfs): Retorna um CompletableFuture<Void> que se completa quando todos os futures passados se completam.
- anyOf(CompletableFuture<?>... cfs): Retorna um CompletableFuture<Object> que se completa quando qualquer um dos futures passados se completa.
Gestão de exceções:
- exceptionally(Function<Throwable, T> fn): Gerencia exceções retornando um valor alternativo.
- handle(BiFunction<T, Throwable, U> fn): Gerencia tanto o resultado quanto a exceção.

Exemplo:

// Executar uma tarefa assíncrona
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000); // Simulação de trabalho prolongado
    } catch (InterruptedException e) {
        throw new IllegalStateException(e);
    }
    return "Resultado da operação assíncrona";
});

// Realizar uma ação após a conclusão da tarefa (não bloqueante)
future.thenAccept(result -> {
    System.out.println("Resultado obtido: " + result);
});

// Outra ação que depende da primeira
future.thenApply(String::toUpperCase)
      .thenAccept(upperCaseResult -> {
          System.out.println("Resultado em maiúsculas: " + upperCaseResult);
      });

// Aguardar todas as tarefas (em aplicações reais, geralmente evita-se usar get/join explicitamente)
// future.join();

CompletableFuture é uma ferramenta poderosa para escrever código reativo e não bloqueante em Java, simplificando significativamente o trabalho com assíncronismo em comparação com a interface clássica Future.

Fale sobre o conceito da classe CompletableFuture.