How to use allOf() correctly?

• allOf() – returns CompletableFuture because input futures may have different types (String, Integer, BigDecimal).
• Result collection – call .join() on each individual future after allOf completes.
• Fail-all – allOf().join() throws if any future failed; reject entire operation for strict consistency.
• Partial results – swallow allOf exception, check each isCompletedExceptionally(), return what succeeded.
• Fallbacks – chain exceptionally(ex -> default) on each future before allOf; all futures always succeed.
• Choice – fail-all for critical decisions (loan approval); fallbacks for dashboards and best-effort displays.

Why does allOf() return Void?

The input futures may have different types: CF, CF, CF. Java cannot express a heterogeneous tuple, so allOf returns Void and you collect results individually.

CF<Integer> balance = supplyAsync(() -> getBalance("SAV2001"));
CF<Integer> score = supplyAsync(() -> getCreditScore("SAV2001"));
CF<BigDecimal> property = supplyAsync(() -> getPropertyValue("P001"));

CompletableFuture<Void> allDone = CompletableFuture.allOf(balance, score, property);
allDone.join(); // waits for all, returns null

int b = balance.join();        // already done
int s = score.join();          // already done
BigDecimal p = property.join(); // already done

Strategy 1: Fail-all

If any future fails, allOf().join() throws. The entire operation is rejected.

try {
    CompletableFuture.allOf(balance, score, property).join();
    return decide(balance.join(), score.join(), property.join());
} catch (CompletionException e) {
    return "REJECTED: " + e.getCause().getMessage();
}

Strategy 2: Partial results

Swallow the allOf exception, check each future individually, return what succeeded.

CompletableFuture.allOf(balance, score, property)
    .exceptionally(ex -> null) // swallow
    .join();

Map<String, Object> results = new HashMap<>();
if (!balance.isCompletedExceptionally()) results.put("balance", balance.join());
if (!score.isCompletedExceptionally()) results.put("score", score.join());
if (!property.isCompletedExceptionally()) results.put("property", property.join());

Strategy 3: Fallbacks (most resilient)

Chain exceptionally() on each future before allOf. Every future always succeeds.

CF<Integer> safeBalance = balance.exceptionally(ex -> 0);
CF<Integer> safeScore = score.exceptionally(ex -> 500);
CF<BigDecimal> safeProperty = property.exceptionally(ex -> BigDecimal.ZERO);

CompletableFuture.allOf(safeBalance, safeScore, safeProperty).join();
// All always succeed with real or fallback values

When to use each strategy?

| Strategy | Use case | Trade-off |
|---|---|---|
| Fail-all | Loan decision (needs all real data) | Higher error rate |
| Partial | Dashboard (show what's available) | Incomplete data |
| Fallback | Resilient display (cached defaults) | May show stale data |

How do you collect homogeneous results?

When all futures have the same type, use a stream.

List<CF<String>> futures = accountIds.stream()
    .map(id -> supplyAsync(() -> fetchBalance(id)))
    .toList();

CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();

List<String> results = futures.stream()
    .map(CompletableFuture::join)
    .toList();

What are common interview follow-up questions?

• Why not return a tuple? Java does not have tuples. allOf would need a heterogeneous container.
• Does allOf wait for all even if one fails? Yes, allOf waits for all to complete (success or failure) before completing.
• Can you use anyOf for fail-fast? Yes, anyOf completes when the first future completes (success or failure).