I am late to the party but here are my 2 cents

I am writing here about these three methods—thenApply(), thenCompose(), and thenCombine().. They might seem similar initially, but they serve distinct purposes.

1. thenApply()

• Use case: Transform the result of the current CompletableFuture.
• Returns: A new CompletableFuture with the transformed result.
• Execution: Runs the transformation function synchronously (unless combined with thenApplyAsync).

Example:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hi Buddy")
    .thenApply(result -> result + " .How are you?");

future.thenAccept(System.out::println); 

2. thenCompose()

• Use case: Chain multiple asynchronous computations that depend on each other.
• Returns: Flattens nested CompletableFuture instances into a single one.
• Execution: Useful for dependent asynchronous tasks.

Example:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "hi")
    .thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " .. hows life???"));

future.thenAccept(System.out::println);

Here, thenCompose() chains two asynchronous tasks. The second CompletableFuture depends on the result of the first.

Why flatten? Without thenCompose(), you'd end up with CompletableFuture<CompletableFuture<String>>, which isn't useful.

3. thenCombine()

• Use case: Combine two independent CompletableFuture results when both are complete.
• Returns: A new CompletableFuture with the combined result.

Example:

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);

CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);

combinedFuture.thenAccept(System.out::println); // prints 3

Here, thenCombine() takes the results of two independent tasks (future1 and future2) and combines them into a single result (3).

Summary: When to Use What

• thenApply(): Transform the result of a single CompletableFuture.
  Think: Synchronous transformation.

• thenCompose(): Chain dependent asynchronous tasks.
  Think: Task B depends on the result of Task A.

• thenCombine(): Combine results of two independent CompletableFutures.
  Think: Running two tasks in parallel and merging their results.