Creating, merging and extending streams

For this lesson, we'll focus on the practical Java 21 APIs: Collection.stream, Arrays.stream, Stream.of, Stream.empty, Stream.ofNullable, Stream.builder, Stream.concat, primitive concat, and the traps around arrays, closing, parallel streams, and deep concat chains. If you need zipping, pairing, or collection-level splitting, use Combining, flattening, zipping and splitting collections instead of forcing those ideas into concat.

01Picture it first: attach cars, then run the train

A stream source is not a bag of already-computed results. It is a way to obtain elements later. When you concatenate streams, you attach sources into a sequence: first car, second car, then maybe a small single-value car at the front or back.

The important part is nothing travels until a terminal operation starts traversal. That is why concat can be lazy and still preserve left-then-right encounter order.

Fig. 1

A train diagram shows Stream.of adding one car before a left stream, Stream.concat joining left and right streams, and traversal happening only when the terminal operation pulls

Notice the shape. concat is not zip, merge-sort, or interleaving. It is append: drain the first stream, then drain the second.

02Creating streams under the hood: pick the right source

The most common source is a collection. If you already have a List<Order>, start there and let the collection provide its spliterator.

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

final class StreamSourcesDemo {
    record User(String name) { }

    public static void main(String[] args) {
        List<String> list = List.of("api", "db");
        String[] names = {"Mina", "Omar"};
        int[] scores = {10, 20, 30};
        User maybeUser = null;

        System.out.println(list.stream().count());
        System.out.println(Arrays.stream(names).count());
        System.out.println(Arrays.stream(scores).sum());
        System.out.println(Stream.ofNullable(maybeUser).count());
        System.out.println(Stream.<User>empty().count());
    }
}

The output is:

2
2
60
0
0

Notice three things:

• Collection.stream() is the normal collection path.
• Arrays.stream(int[]) gives an IntStream, so sum() works without boxing.
• Stream.ofNullable has existed since Java 9 and is a clean way to turn one nullable reference into zero or one elements.

The array trap is worth calling out because it appears in interviews and code reviews.

import java.util.Arrays;

final class PrimitiveArrayTrapDemo {
    public static void main(String[] args) {
        int[] scores = {10, 20, 30};

        System.out.println(Arrays.asList(scores).size());
        System.out.println(Arrays.stream(scores).count());
    }
}

The output is:

1
3

Arrays.asList(scores) treats the whole int[] as one object because generics cannot use primitive element type int. Use Arrays.stream(scores) for primitive arrays. For Integer[], Arrays.asList behaves differently because Integer is a reference type.