Streams, and When the Work Happens

A stream lets you describe the stages, and then runs them together over one element at a time.

List<String> result = names.stream()
    .filter(n -> n.length() > 4)
    .map(String::toUpperCase)
    .toList();

filter takes a Predicate. map takes a Function. Both are from Section 11.2, and String::toUpperCase is a method reference. Nothing here is a new kind of thing.

Every stream has exactly three parts.

Without a terminal operation, nothing runs. Not “runs and throws the answer away”. Nothing runs:

names.stream().filter(n -> {
    System.out.println("filter sees " + n);
    return n.length() > 4;
});

Run that. Nothing is printed. The lambda is never called, no element is looked at, and no exception is raised. The code compiles, runs, and does nothing at all.

Streams do not change the source. names is exactly as it was afterwards. A stream reads; it never writes back.

A stream can be infinite. That only makes sense because of the laziness:

Stream.iterate(1, x -> x * 2).limit(8).toList();
// [1, 2, 4, 8, 16, 32, 64, 128]

Stream.iterate describes an endless sequence. It does not build one. limit(8) says stop after eight, and because nothing runs until the terminal operation, only eight values are ever produced.

Answer from memory before opening the explanation. Then compare your rule with the answer and revisit the example if they differ.

1. You write a stream with `filter` and `map` and no terminal operation. What runs?

   Show the answer

   Nothing. Not one element is looked at, and neither lambda is ever called.

   Intermediate operations do not do work. Each one returns a new stream carrying a note of what was asked for. The notes pile up and sit there.

   A terminal operation is what makes any of it run. Until one arrives, you have written a description of some work, and descriptions do nothing.

   This is also why a stream with no terminal operation is a silent bug. The code compiles, it runs, no exception appears, and your list is unchanged.

2. For a list of four names, does `filter` run on all four before `map` runs on any?

   Show the answer

   No. They interleave, one element at a time.

   The real order, printed from inside the lambdas: filter Aditya, map Aditya, filter Rohit, map Rohit, filter Rohan, map Rohan, filter Sonu. Then the answer.

   Each element is carried the whole way down the pipeline before the next one starts. Sonu fails the filter, so map never sees it at all.

   That is why a stream over a million elements does not build a million element list at every stage. There is only ever one element in flight.

3. Why can a stream not be used twice?

   Show the answer

   Because it holds a position, not data. A stream is closer to the iterator from Section 10.2 than to the list it came from.

   Once a terminal operation has walked it, the walk is over. Ask for another and you get IllegalStateException: stream has already been operated upon or closed.

   The fix is to make a new one. list.stream() is cheap and creates a fresh walk over the same list, so call it again rather than storing a stream in a variable and reaching for it twice.

Write each solution in VS Code, predict its result, and then run the checks. Reading an example does not replace implementing it.

4 exercises80 pointsabout 80 minutes

import java.util.*;

public class NothingRan {
    public static void main(String[] args) {
        List<String> names = List.of("Aditya", "Rohit", "Rohan", "Sonu");

        // TODO: a stream with a filter that PRINTS, and no terminal operation.
        //       Predict the output before running.

        // TODO: now add .toList() to the end and run it again

        // TODO: put a print inside a map as well, and predict the ORDER of the
        //       two kinds of line before running. This is the important one.
    }
}

import java.util.*;
import java.util.stream.*;

public class ShortCircuit {
    static int checks = 0;

    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 1; i <= 1000; i++) numbers.add(i);

        // TODO: findFirst on a filter that counts every check.
        //       How many of the 1000 get looked at?

        // TODO: same filter with toList instead. How many now?

        // TODO: anyMatch, allMatch, noneMatch. Count for each and explain the numbers.

        // TODO: Stream.iterate(1, x -> x * 2) with a limit. Then try it WITHOUT
        //       the limit and be ready to stop the program yourself.
    }
}

import java.util.*;
import java.util.stream.*;

public class BothWays {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        for (int i = 0; i < 1_000_000; i++) names.add("name" + i);

        // Job: names longer than 7 characters, in capitals, first ten only.

        // TODO: write it with loops. Count the intermediate lists you had to build
        //       and how many entries each one held.

        // TODO: write it as one stream.

        // TODO: check the two answers match, then time both

        // TODO: add a print inside the stream's map. How many times does it run?
    }
}

import java.util.*;
import java.util.stream.*;

public class Twice {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>(List.of("Aditya", "Rohit", "Rohan"));

        // TODO: store a stream in a variable, use a terminal operation twice,
        //       and read the exception message carefully

        // TODO: fix it, without storing the stream

        // TODO: make a stream, then ADD to the list, then run the terminal
        //       operation. Does the new name appear? Predict first.

        // TODO: does the source list change after a map to uppercase? Check.
    }
}