From Iterating to Stream Operations in Java

When you process a collection, you usually iterate over its elements and do some work with each of them. For example, suppose we want to count all long words in a book. First, let’s put them into a list:

var contents = Fites.readStr(

Paths.get(“alice.txt”)); // Read file into string

List<String> words = List.of(contents.split(“\\PL+”));

// Split into words; nonletters are delimiters

Now we are ready to iterate:

int count = 0;

for (String w : words) {

if (w.length() > 12) count++;


With streams, the same operation looks like this:

long count =

.filter(w -> w.length() > 12)


Now you don’t have to scan the loop for evidence of filtering and counting. The method names tell you right away what the code intends to do. Moreover, where the loop prescribes the order of operations in complete detail, a stream is able to schedule the operations any way it wants, as long as the result is correct.

Simply changing stream to parallelStream allows the stream library to do the filtering and counting in parallel.

long count = words.parallelStream()

.filter(w -> w.length() > 12)


Streams follow the “what, not how” principle. In our stream example, we describe what needs to be done: get the long words and count them. We don’t specify in which order, or in which thread, this should happen. In contrast, the loop at the beginning of this section specifies exactly how the computation should work, and thereby forgoes any chances of optimization.

A stream seems superficially similar to a collection, allowing you to transform and retrieve data. But there are significant differences:

  1. A stream does not store its elements. They may be stored in an underlying collection or generated on demand.
  2. Stream operations don’t mutate their source. For example, the fitter method does not remove elements from a stream but yields a new stream in which they are not present.
  3. Stream operations are lazy when possible. This means they are not exe­cuted until their result is needed. For example, if you only ask for the first five long words instead of all, the fitter method will stop filtering after the fifth match. As a consequence, you can even have infinite streams!

Let us have another look at the example. The stream and parattetStream methods yield a stream for the words list. The fitter method returns another stream that contains only the words of length greater than twelve. The count method reduces that stream to a result.

This workflow is typical when you work with streams. You set up a pipeline of operations in three stages:

  1. Create a stream.
  2. Specify intermediate operations for transforming the initial stream into others, possibly in multiple steps.
  3. Apply a terminal operation to produce a result. This operation forces the execution of the lazy operations that precede it. Afterwards, the stream can no longer be used.

In the example in Listing 1.1, the stream is created with the stream or parattetStream method. The fitter method transforms it, and count is the terminal operation.

In the next section, you will see how to create a stream. The subsequent three sections deal with stream transformations. They are followed by five sections on terminal operations.

Source: Horstmann Cay S. (2019), Core Java. Volume II – Advanced Features, Pearson; 11th edition.

Leave a Reply

Your email address will not be published. Required fields are marked *