Introduction to Java streams

For this lesson, we'll focus on the beginner model you need before any collector, parallel stream or puzzle makes sense: what a stream is, how a source becomes a pipeline, how to create streams from everyday inputs, how to convert an Iterable, and when a loop is still the better tool. Interviewers ask this because many candidates can write .filter().map().collect(), but fewer can explain what actually exists before the terminal operation runs.

01Picture it first: a recipe card, not a pantry

Think of a stream as a recipe card clipped to a source. The pantry is your List<Order> or file; the stream is the card that says, "keep paid orders, turn each into cents, add them up." Until someone starts cooking, no ingredients move.

The picture to keep in your head is source, pipeline, terminal operation. The stream object is the plan, not a box of copied elements.

Fig. 1

A source feeds a stream pipeline with filter and map stages, then a terminal operation pulls results from the source

Notice three things. The source owns the data. The intermediate stages describe transformations. The terminal operation is the thing that pulls, counts, collects or performs side effects.

A stream may also be unbounded. Stream.generate(UUID::randomUUID) can keep producing values forever, so you normally pair it with limit, findFirst, anyMatch or another short-circuiting terminal operation. We cover infinite sources more deeply in Infinite streams with iterate and generate.

02Stream basics under the hood: build a pipeline

import java.util.List;

record Order(String id, String customerId, int cents, boolean paid) { }

final class StreamShapeDemo {
    public static void main(String[] args) {
        List<Order> orders = List.of(
                new Order("o-1", "c-1", 1200, true),
                new Order("o-2", "c-2", 800, false),
                new Order("o-3", "c-1", 300, true)
        );

        int paidCents = orders.stream()                 // source
                .filter(Order::paid)                    // intermediate
                .mapToInt(Order::cents)                 // intermediate
                .sum();                                 // terminal

        System.out.println(paidCents); // 1500
    }
}

Notice what did not happen. filter did not create a new List<Order>. mapToInt did not eagerly create an array of ints. The traversal happened when sum() asked the pipeline for elements.

This is the first correction I make in interviews: a stream has no storage of its own. Some operations may buffer internally, for example sorted, but that buffer belongs to pipeline execution, not to the stream as a reusable container.

Streams are also one-shot. Once a terminal operation has consumed the pipeline, the stream is considered operated upon or closed.

import java.util.List;
import java.util.stream.Stream;

final class OneShotStreamDemo {
    public static void main(String[] args) {
        Stream<String> statuses = List.of("paid", "refunded", "paid").stream();

        long paid = statuses.filter("paid"::equals).count();
        System.out.println(paid); // 2

        // statuses.count(); // IllegalStateException: stream has already been operated upon or closed
    }
}

The safe default is to store the source, not the stream. If you need the same calculation twice, call orders.stream() twice or extract a method that creates the pipeline from the source.

03Every common way to create a stream

The creation API is broad because Java code has many sources: collections, arrays, files, strings, regular expressions, ranges and custom iterables. You do not need to memorize every overload, but you should know the families.

Fig. 2

Common stream sources include collections, arrays, factories, ranges, files, strings, regex splits, iterables, builders and generated sequences

Here is the quick map I keep in my head.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.IntStream;
import java.util.stream.Stream;

final class StreamCreationDemo {
    public static void main(String[] args) throws IOException {
        List<String> statuses = List.of("paid", "failed", "paid");
        System.out.println(statuses.stream().filter("paid"::equals).count());

        int[] cents = {1200, 800, 300};
        System.out.println(Arrays.stream(cents).sum());

        System.out.println(Stream.of("card", "upi", "wallet").count());
        System.out.println(Stream.ofNullable(null).count());       // since Java 9
        System.out.println(IntStream.range(0, 3).boxed().toList());
        System.out.println("A🙂".codePoints().count());             // 2 code points
        System.out.println(Pattern.compile(",").splitAsStream("a,b,c").toList());
        System.out.println(Stream.iterate(1, n -> n + 1).limit(3).toList());
        System.out.println(Stream.generate(() -> "tick").limit(2).toList());

        Stream.Builder<String> builder = Stream.builder();
        builder.add("created");
        builder.add("paid");
        System.out.println(builder.build().toList());

        Path file = Path.of("stream-creation-demo-orders.txt");
        Files.writeString(file, "o-1\no-2\n");
        try (Stream<String> lines = Files.lines(file)) {
            System.out.println(lines.count());
        }
        Files.deleteIfExists(file);
    }
}

Files.lines is the one that should make you pause. It returns a stream backed by an open file, so use try-with-resources. A collection stream does not need manual closing, but closing is still legal and triggers registered close handlers if there are any.

For String, choose carefully. chars() gives UTF-16 code units, so an emoji outside the Basic Multilingual Plane appears as two char values. codePoints() is usually the safer choice when you mean user-visible Unicode code points. We revisit strings in Stream recipes: indices, last element and strings.

04Iterable to Stream in Java

Iterable is the interface behind the enhanced for loop. It gives you an Iterator, not a stream() method. If the concrete type is a Collection, prefer collection.stream(); if all you have is Iterable<T>, bridge through its Spliterator.

import java.util.List;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

final class IterableToStreamDemo {
    static <T> Stream<T> streamOf(Iterable<T> iterable) {
        return StreamSupport.stream(iterable.spliterator(), false);
    }

    public static void main(String[] args) {
        Iterable<String> ids = List.of("o-1", "o-2", "o-3");

        List<String> upper = streamOf(ids)
                .map(String::toUpperCase)
                .toList();

        System.out.println(upper); // [O-1, O-2, O-3]
    }
}

The second argument to StreamSupport.stream says whether to create a parallel stream. Use false by default. A random Iterable may not split well, and a parallel stream over a poor Spliterator usually adds overhead without useful parallelism.

05Advanced: loop rewrite, trade-offs and good defaults

The best stream rewrites keep the business question visible. Here is a realistic loop: count the total paid cents for non-test orders in one region, skipping cancelled orders and ignoring tiny refund adjustments.

import java.util.List;

record Order(String id, String region, String status, int cents, boolean test) { }

final class LoopVsStreamDemo {
    static int paidCentsLoop(List<Order> orders, String region) {
        int total = 0;
        for (Order order : orders) {
            if (order.test()) continue;
            if (!"PAID".equals(order.status())) continue;
            if (!region.equals(order.region())) continue;
            if (order.cents() <= 0) continue;
            total += order.cents();
        }
        return total;
    }

    static int paidCentsStream(List<Order> orders, String region) {
        return orders.stream()
                .filter(order -> !order.test())
                .filter(order -> "PAID".equals(order.status()))
                .filter(order -> region.equals(order.region()))
                .mapToInt(Order::cents)
                .filter(cents -> cents > 0)
                .sum();
    }

    public static void main(String[] args) {
        List<Order> orders = List.of(
                new Order("o-1", "west", "PAID", 1200, false),
                new Order("o-2", "west", "FAILED", 800, false),
                new Order("o-3", "east", "PAID", 500, false),
                new Order("o-4", "west", "PAID", -100, false),
                new Order("o-5", "west", "PAID", 300, true)
        );

        System.out.println(paidCentsLoop(orders, "west"));
        System.out.println(paidCentsStream(orders, "west"));
    }
}

Both versions print 1200. The stream version is good because the operation is a straight transformation and reduction. The loop version is still good, and sometimes better, when each branch needs logging, metrics, checked exceptions, mutation, or a named reason that will show up in a debugger.

Many candidates convert every loop into a stream to look modern. That is frequently a mistake. The default I recommend is: use a stream when you can name the work as filter, map, flatMap, sort, limit, collect or reduce; use a loop when the work is control flow.

06How to say it in the interview

When I ask this question, I'm listening for the mental model: a stream is a one-use pipeline over a source, not a collection. I also want to hear that you know several sources, that intermediate operations are lazy, and that you won't force streams into code where a loop is clearer.