Stream API

The Stream API, added in Java 8, provides a declarative way to process sequences of data — collections, arrays, or I/O sources — using a pipeline of operations rather than explicit loops. A stream describes what should happen to the data, not the mechanics of how to iterate over it.

Streams are built around a simple pipeline shape: a source produces elements, zero or more intermediate operations transform or filter them, and exactly one terminal operation triggers execution and produces a result or side effect.

Why it matters

Filtering a list, converting each element, grouping and totalling are the most common things done to data, and the Stream API expresses all of them as a short pipeline. Stream code is in every modern Java codebase, and stream questions are in almost every Java interview from junior level upwards.

The Stream Pipeline

A typical pipeline looks like collection.stream().filter(...).map(...).sorted(...).collect(...). filter keeps elements matching a Predicate, map transforms each element with a Function, and sorted orders elements — these are all intermediate operations that return a new stream. The pipeline only actually runs when a terminal operation like collect, forEach, reduce, count, or anyMatch is called.

Lazy Evaluation

Intermediate operations are lazy: calling .filter() or .map() does not process any elements immediately. Java only walks through the source data once, when a terminal operation is invoked, and it processes each element through the entire chain of intermediate operations before moving to the next one. This means a stream with no terminal operation does nothing at all, and short-circuiting operations like findFirst() can stop processing early.

Streams Are Not Reusable

Once a terminal operation consumes a stream, that stream is considered closed and cannot be reused — calling another operation on it throws an IllegalStateException. If you need to process the same data twice, you must create a new stream from the source collection each time.

Example

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Charlie", "amy", "Bob", "diana");

        List<String> result = names.stream()
                .filter(n -> n.length() > 3) // "amy" and "Bob" are dropped here
                .map(String::toUpperCase)
                .sorted()
                .collect(Collectors.toList());
        System.out.println(result);

        int totalLength = names.stream()
                .mapToInt(String::length)
                .reduce(0, Integer::sum);
        System.out.println("Total length: " + totalLength);
    }
}

[CHARLIE, DIANA]
Total length: 18

Exercise

From the list of numbers, keep those greater than 6, double each one, sort the result and collect it into a list. Then print the sum of that list.

Expected output: [16, 24, 40] then 80

import java.util.List;
import java.util.stream.Collectors;

public class StreamPipeline {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(5, 12, 8, 3, 20);

        // TODO: filter (> 6), map (double), sorted, collect to a list
        // TODO: print the list
        // TODO: print the sum of the list
    }
}

import java.util.List;
import java.util.stream.Collectors;

public class StreamPipeline {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(5, 12, 8, 3, 20);

        List<Integer> result = numbers.stream()
                .filter(n -> n > 6)
                .map(n -> n * 2)
                .sorted()
                .collect(Collectors.toList());

        System.out.println(result); // [16, 24, 40]

        int sum = result.stream().mapToInt(Integer::intValue).sum();
        System.out.println(sum); // 80
    }
}

Quick quiz

Interview questions