What are the main features of the Java 8 Stream API?

Java 8 Stream API

By Nikola Pashov

JavaMidjava

What a Strong Answer Covers

• lazy evaluation
• pipelining/chaining
• internal iteration
• parallelStream
• filter/map/reduce operations
• intermediate vs terminal operations
• functional approach

Senior-Level Answer

The Stream API, introduced in Java 8 in `java.util.stream`, enables functional-style processing of sequences of elements through declarative, composable pipelines. A stream is not a data structure — it does not store data. It conveys elements from a source (collection, array, generator function, I/O channel) through a pipeline of operations.

A stream pipeline has three parts: 1. **Source**: `collection.stream()`, `Arrays.stream(arr)`, `Stream.of(...)`, `Stream.generate(supplier)`, `Stream.iterate(seed, function)`. 2. **Intermediate operations**: lazy — they return a new stream and are not executed until a terminal operation is called. Examples: `filter(predicate)`, `map(function)`, `flatMap(function)`, `distinct()`, `sorted()`, `limit(n)`, `peek(consumer)`. 3. **Terminal operations**: trigger the pipeline to execute. Examples: `collect(collector)`, `forEach(consumer)`, `reduce(identity, accumulator)`, `count()`, `findFirst()`, `anyMatch(predicate)`, `toList()` (Java 16).

Laziness is a key design feature. Intermediate operations are fused; the stream processes elements one at a time through the entire pipeline rather than creating intermediate collections. This enables short-circuit operations like `findFirst()` to stop processing as soon as a match is found.

Parallel streams (`collection.parallelStream()`) distribute work across the ForkJoinPool's common pool. They are useful for CPU-bound operations on large datasets but counterproductive for small collections or I/O-bound tasks due to thread management overhead and potential race conditions with non-thread-safe collectors.

`Collectors` provides rich terminal operations: `toList()`, `toSet()`, `groupingBy()`, `partitioningBy()`, `joining()`, `counting()`, and more. `Collectors.groupingBy()` is one of the most powerful — it produces a `Map<K, List<V>>` grouping elements by a classifier function.

Streams are consumed once — reusing a stream after a terminal operation throws `IllegalStateException`.

What Separates a 2/3 from a 3/3

Common Mistakes

• Treating streams as collections — streams are pipelines that process data, not data structures that store it.
• Using parallel streams indiscriminately — they add overhead and can hurt performance for small collections or I/O-bound operations.
• Attempting to reuse a stream after a terminal operation, which throws IllegalStateException.

Follow-Up Questions

• What is the difference between map() and flatMap() in Stream? — map() transforms each element 1-to-1; flatMap() maps each element to a Stream and merges (flattens) those streams into one.
• When would parallel streams hurt performance instead of helping? — Small datasets (thread overhead dominates), ordered operations requiring merging (findFirst on parallel), shared mutable state, or I/O-bound tasks.
• How does lazy evaluation enable short-circuit processing in streams? — Terminal ops like findFirst() and anyMatch() signal the pipeline to stop once the condition is satisfied, skipping remaining elements.