Java Stream Efficiency Analysis and Performance Comparison with Iterator

Java SE 8 introduced the Stream API (java.util.stream) as a new abstraction for processing sequences of elements. A stream represents a value sequence and provides a rich set of aggregate operations, allowing convenient functional-style processing of collections, arrays, and other data structures.

Types of Stream Operations

Intermediate Operations

All operations applied to the data after it enters the pipeline are called intermediate operations.

Intermediate operations return another stream, enabling the chaining of multiple operations into a pipeline.

Common intermediate operations include filter , distinct , map , sorted , etc.

Terminal Operations

After all intermediate operations are defined, a terminal operation is required to produce a result or to extract data from the pipeline.

Terminal operations can return a collection, an array, a string, or any other concrete result.

Characteristics of Streams

Can Be Traversed Only Once

Once an element has passed through the pipeline, it cannot be processed again; a new stream must be created from the source for further operations.

Uses Internal Iteration

Traditional collection processing relies on external iteration via an Iterator . Streams, by contrast, perform internal iteration, allowing the runtime to manage traversal, which is generally more efficient for large data sets.

Efficiency Comparison Between Stream and Iterator

Key findings from benchmark tests:

For small data volumes (size ≤ 1,000), traditional iterator loops are faster than Stream operations, though the difference is usually sub‑millisecond and negligible for most business logic.

For large data volumes (size > 10,000), Stream processing—especially parallel streams—outperforms iterator loops, provided the CPU has multiple cores to exploit parallelism.

Parallel streams depend heavily on CPU core availability; on a single‑core machine, the overhead of the ForkJoinPool can make them slower than sequential streams.

Test Environment

System: Ubuntu 16.04 xenial CPU: Intel Core i7‑8550U (16 GB RAM) JDK version: 1.8.0_151 JVM: HotSpot 64‑Bit Server VM (build 25.151‑b12) JVM Settings: -Xms1024m -Xmx6144m -XX:MaxMetaspaceSize=512m -XX:ReservedCodeCacheSize=1024m -XX:+UseConcMarkSweepGC -XX:SoftRefLRUPolicyMSPerMB=100

Benchmark Scenarios

1. Mapping Test

Increment each integer in a random list and collect the results into a new list. List sizes range from 10 to 10,000,000, with 10 runs per size.

2. Filtering Test

Select elements greater than 200 from a random list and collect them into a new list. List sizes range from 10 to 10,000,000.

3. Sorting Test

Sort a random list using natural order. The iterator version uses Collections.sort (merge sort).

4. Reduction Test

Find the maximum value in a random list.

5. String Joining Test

Join all elements of a random list into a comma‑separated string.

// stream
String result = list.stream().map(String::valueOf).collect(Collectors.joining(","));

// iterator
StringBuilder builder = new StringBuilder();
for (Integer e : list) {
    builder.append(e).append(",");
}
String result = builder.length() == 0 ? "" : builder.substring(0, builder.length() - 1);

// parallel stream
String result = list.parallelStream().map(String::valueOf).collect(Collectors.joining(","));

6. Mixed Operations Test

Perform null removal, deduplication, mapping, filtering, and collect the results into a new list.

Experimental Results Summary

For small data sets (≤ 1,000), iterator loops are faster, but the absolute time difference is negligible; Streams provide cleaner code.

For large data sets (> 10,000), Streams—especially parallel streams—offer superior performance when the CPU can allocate multiple cores.

Parallel streams' benefit is highly dependent on the underlying hardware; on single‑core CPUs they may be slower due to ForkJoinPool overhead.

Recommendations for Using Streams

Use simple iterator loops for straightforward iteration. For multi‑step processing, prefer Streams to gain readability with minimal performance loss.

Avoid parallel streams on single‑core CPUs; employ them on multi‑core systems with large data volumes.

When a Stream contains boxed types, convert to primitive streams (e.g., IntStream ) before intermediate operations to reduce boxing/unboxing overhead.

Source: blog.csdn.net/Al_assad/ article/details/82356606