8.3 Terminal Stream Operations: Reduction, Matching, Finding, and Collecting

8.3 Terminal Stream Operations: Reduction, Matching, Finding, and Collecting

Terminal operations represent the culmination of a stream pipeline. When a terminal operation is invoked, the JVM initiates traversal of the backing data source, pulls elements through intermediate operations, executes reductions or side effects, and permanently closes the stream. Terminal operations are categorized into iteration, search/matching, and reductions.

---

Element Traversal and Iteration

forEach(Consumer<? super T>) vs. forEachOrdered(Consumer<? super T>)

Both methods iterate over each element of the stream and apply a Consumer side effect:

• forEach: Iterates through elements without guaranteeing encounter order in parallel streams. This permits worker threads in the ForkJoinPool to process elements as soon as they become available.
• forEachOrdered: Enforces strict encounter order during iteration, even across parallel streams. However, enforcing order in parallel streams incurs synchronization overhead and negates concurrency advantages.

List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8);

// Non-deterministic output order in parallel execution
numbers.parallelStream().forEach(n -> System.out.print(n + " "));

// Deterministic output order (1 2 3 4 5 6 7 8) in parallel execution
numbers.parallelStream().forEachOrdered(n -> System.out.print(n + " "));

---

Finding Operations: findFirst() vs. findAny()

Finding operations search for an element in the stream and return an Optional<T>. If the stream is empty, both methods return Optional.empty().

• findFirst(): Returns the very first element in the stream's encounter order. It is completely deterministic in both sequential and parallel streams. In parallel execution, it must wait for earlier partitions to finish to guarantee it has the true first element.
• findAny(): Returns any arbitrary element encountered in the stream. In sequential pipelines, it typically returns the first element; however, in parallel pipelines, it returns whichever element is processed first by any thread, offering maximum concurrency performance.

List<String> names = List.of("David", "Alice", "Bob", "Charlie");

Optional<String> first = names.parallelStream()
    .filter(s -> s.length() > 3)
    .findFirst(); // Guaranteed to return Optional[David]

Optional<String> any = names.parallelStream()
    .filter(s -> s.length() > 3)
    .findAny(); // Could return Optional[David], Optional[Alice], or Optional[Charlie]

Both findFirst() and findAny() are short-circuiting: they immediately terminate the pipeline as soon as a matching element is found, without evaluating remaining upstream elements.

---

Predicate Matching and the Empty Stream Truth Table

Java provides three boolean matching operations that test stream elements against a Predicate. All three are short-circuiting terminal operations:

• anyMatch(Predicate): Returns true if at least one element satisfies the predicate. Short-circuits immediately upon encountering the first true.
• allMatch(Predicate): Returns true if every element satisfies the predicate. Short-circuits immediately upon encountering the first false.
• noneMatch(Predicate): Returns true if no elements satisfy the predicate. Short-circuits immediately upon encountering the first true.

The Empty Stream Truth Table Trap

A notorious exam topic involves matching operations applied to an empty stream. In formal mathematical logic, universal quantification over an empty set is vacuously true:

Stream<String> emptyStream1 = Stream.empty();
Stream<String> emptyStream2 = Stream.empty();
Stream<String> emptyStream3 = Stream.empty();

boolean b1 = emptyStream1.allMatch(s -> s.length() > 100);  // true!
boolean b2 = emptyStream2.noneMatch(s -> s.length() > 100); // true!
boolean b3 = emptyStream3.anyMatch(s -> s.length() > 100);  // false!

---

General Reduction with reduce()

A reduction operation folds a sequence of elements into a single summary result by repeatedly applying a binary accumulation function. Java provides three overloaded variants of reduce() in Stream<T>:

1. 1-Argument Reduction: Optional<T> reduce(BinaryOperator<T> accumulator)

Combines elements using only an accumulator. Because no identity value is supplied, this method returns an Optional<T> containing Optional.empty() if the stream contains zero elements:

List<Integer> nums = List.of(3, 5, 7);
Optional<Integer> product = nums.stream().reduce((a, b) -> a * b); // Optional[105]

Optional<Integer> empty = Stream.<Integer>empty().reduce((a, b) -> a + b); // Optional.empty

2. 2-Argument Reduction: T reduce(T identity, BinaryOperator<T> accumulator)

Provides an explicit identity value. The identity serves two roles:

1. It is the initial seed for the accumulation.
2. It is the default return value if the stream is empty.

Because an identity value is guaranteed, this method returns T directly rather than Optional<T>:

List<Integer> values = List.of(10, 20, 30);
int sum = values.stream().reduce(0, (a, b) -> a + b); // 60

int emptySum = Stream.<Integer>empty().reduce(0, (a, b) -> a + b); // Returns identity: 0

3. 3-Argument Reduction: <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner)

The 3-argument overload is used when the accumulated result type U differs from the stream element type T. It takes three components:

1. U identity: Initial seed of type U.
2. BiFunction<U, T, U> accumulator: Folds a stream element T into the running accumulation U.
3. BinaryOperator<U> combiner: Merges two accumulated values of type U.

List<String> words = List.of("Java", "17", "Developer");

// Sum total character lengths into an Integer
int totalChars = words.stream().reduce(
    0,                                  // U identity
    (Integer acc, String s) -> acc + s.length(), // BiFunction accumulator
    (Integer c1, Integer c2) -> c1 + c2          // BinaryOperator combiner
);
System.out.println(totalChars); // 15

---

Extrema Operations: min() and max()

The min(Comparator) and max(Comparator) methods are specialized reductions that find the smallest or largest element according to a Comparator:

List<String> fruits = List.of("kiwi", "banana", "pear", "watermelon");

Optional<String> shortest = fruits.stream().min(Comparator.comparingInt(String::length));
// Optional[kiwi] (min keeps the first of the tied four-letter words)

Optional<String> longest = fruits.stream().max(Comparator.comparingInt(String::length));
// Optional[watermelon]

Both methods return Optional<T>. If the stream is empty, they return Optional.empty().