能否在Java Stream中使用单次流操作执行多个allMatch()校验，替代多次流调用的写法？

Great question! Repeatedly spinning up streams and calling allMatch() for each condition is inefficient—you’re potentially iterating over your collection multiple times (once per condition, worst case). Let’s fix this by validating all your requirements in a single pass, while keeping the short-circuit behavior that makes allMatch() useful.

Option 1: Simple Iteration with Short-Circuit Checks (Best for Most Cases) #

If you don’t need parallel stream support, a straightforward forEach loop with a boolean array to track condition results is clean and efficient. It mimics allMatch()’s short-circuit behavior: once a condition fails, we stop checking it for subsequent items.

// Define your conditions first (replace T with your item type)
Predicate<T> condition1 = item -> /* your first validation logic */;
Predicate<T> condition2 = item -> /* your second validation logic */;
Predicate<T> condition3 = item -> /* your third validation logic */;

// Track if each condition is still satisfied
boolean[] conditionStatus = {true, true, true};

items.forEach(item -> {
    // Only check a condition if it's still passing so far
    if (conditionStatus[0]) conditionStatus[0] = condition1.test(item);
    if (conditionStatus[1]) conditionStatus[1] = condition2.test(item);
    if (conditionStatus[2]) conditionStatus[2] = condition3.test(item);
});

// All conditions must be true to pass
boolean allConditionsMet = conditionStatus[0] && conditionStatus[1] && conditionStatus[2];

Option 2: Stream reduce() for Parallel-Friendly Validation #

If you need to support parallel streams (for large collections), use reduce() to accumulate condition results across all elements. We’ll use a simple helper class to keep track of each condition’s status, and the combiner ensures results are merged correctly in parallel.

// Helper class to hold our validation results clearly
class ValidationResults {
    boolean cond1Passed;
    boolean cond2Passed;
    boolean cond3Passed;

    ValidationResults(boolean c1, boolean c2, boolean c3) {
        this.cond1Passed = c1;
        this.cond2Passed = c2;
        this.cond3Passed = c3;
    }
}

// Your conditions (replace T with your actual item type)
Predicate<T> condition1 = item -> /* your first validation logic */;
Predicate<T> condition2 = item -> /* your second validation logic */;
Predicate<T> condition3 = item -> /* your third validation logic */;

ValidationResults finalResults = items.stream()
    .reduce(
        // Initial state: all conditions start as passing
        new ValidationResults(true, true, true),
        // Accumulator: update results for each item (short-circuits with &&)
        (results, item) -> new ValidationResults(
            results.cond1Passed && condition1.test(item),
            results.cond2Passed && condition2.test(item),
            results.cond3Passed && condition3.test(item)
        ),
        // Combiner: merge results from parallel stream chunks
        (leftResults, rightResults) -> new ValidationResults(
            leftResults.cond1Passed && rightResults.cond1Passed,
            leftResults.cond2Passed && rightResults.cond2Passed,
            leftResults.cond3Passed && rightResults.cond3Passed
        )
    );

boolean allConditionsMet = finalResults.cond1Passed && finalResults.cond2Passed && finalResults.cond3Passed;

Why This Is Better Than Your Original Code #

• Single Iteration: No matter how many conditions you have, we only loop through your collection once (instead of once per condition).
• Preserves Short-Circuiting: Just like allMatch(), we stop checking a condition as soon as it fails for any item.
• Lower Overhead: Avoids the cost of creating multiple stream instances and their associated infrastructure.

内容的提问来源于stack exchange，提问作者Flavius