العمليات النهائية والتقييم الكسول (laziness)

Written Explanation

The terminal operations

A pipeline has exactly one terminal operation, at the end.

count and collect

count() returns a long, not an int:

long evens = nums.stream().filter(n -> n % 2 == 0).count();

toList() is the shortest way to gather results, and since Java 16 it is built into Stream. collect is the general form. collect(Collectors.joining(", ")) joins strings into one String, and collect(Collectors.toSet()) gathers into a Set. Lesson 5 gives collect its full treatment. The Javadoc for Collectors.toList() says it makes no promise about the kind of list returned or whether it can be changed, so do not rely on modifying it either.

reduce: many items into one

reduce repeatedly combines two values until one remains. It takes a starting value (the identity) and a rule for combining two values:

int sum = nums.stream().reduce(0, Integer::sum);

Think of it as this loop:

int result = 0;                       // the identity
for (int n : nums) { result = result + n; }

The identity must be a value that changes nothing when combined: 0 for addition, 1 for multiplication. If the stream is empty, you get the identity back, so reduce(0, Integer::sum) on no numbers is 0. The combining rule must also be associative (grouping must not change the answer), which addition and maximum are, and the Javadoc requires this so a reduction could run in parallel.

Without an identity, reduce(Integer::max) returns an Optional, because an empty stream has no maximum.

Yes/no questions: anyMatch, allMatch, noneMatch

boolean hasNegative = nums.stream().anyMatch(n -> n < 0);
boolean allSmall    = nums.stream().allMatch(n -> n < 100);
boolean noZero      = nums.stream().noneMatch(n -> n == 0);

The empty stream deserves attention, because the answers can surprise you:

This follows the Javadoc. So allMatch on an empty list says true; check that the list is not empty if that matters to you.

findFirst and a first look at Optional

findFirst() returns the first item that reaches the end of the pipeline. But there may be none, so it cannot just return the item. It returns an Optional, a small box that holds either one value or nothing. (BEG-037 teaches Optional properly; for now you need only two moves.)

String name = people.stream()
    .filter(p -> p.age() > 60)
    .findFirst()                  // Optional<Person>
    .map(Person::name)            // Optional<String>
    .orElse("none");              // String: the name, or "none" if the box is empty

map on an Optional changes the value inside, if there is one. orElse unwraps the box and gives a fallback when it is empty. Printing an Optional directly shows its box form, such as Optional[Person[name=Lina, age=67]] or Optional.empty. Avoid calling get() for now, because it fails on an empty box.

Laziness: nothing happens until the end

Intermediate operations only describe work. They do not do it. The Javadoc says intermediate operations such as filter and map are lazy, and traversal begins only when a terminal operation runs. A pipeline with no terminal operation does nothing. Also, laziness lets Java fuse the stations: instead of filtering the whole list and then mapping the whole list, it can push items through the stations one at a time.

You can see this by putting println in the lambdas. This is for learning only; remember that side effects in lambdas are discouraged in real code.

Short-circuiting: stopping early

Some operations can finish without seeing every item. They are called short-circuiting. anyMatch stops at the first match, allMatch and noneMatch stop at the first counterexample, findFirst stops at the first item, and limit(n) stops after n items. The Javadoc's own example is a search for the first string longer than a thousand characters: only as many elements as needed are examined. Short-circuiting is also what makes it possible to use an endless stream with limit.

forEach

forEach performs an action on each item and returns nothing. It is fine for printing results at the end of a pipeline: names.stream().sorted().forEach(System.out::println). It is not the right tool for building a result by adding to an outside list; use toList() or collect for that.