1. Overview
Stream API is one of the major new features in Java 8.
In this tutorial, we’ll discuss an interesting topic: the difference between Stream.of() and IntStream.range().
2. Introduction to the Problem
We can initialize a Stream object using the Stream.of() method, e.g., Stream.of(1, 2, 3, 4, 5). Alternatively, if we want to initialize a Stream of integers, IntStream is a more straightforward type to use, for instance, IntStream.range(1, 6). However, the behaviors of integer Streams created by these two approaches can be different.
As usual, we’ll understand the problem through an example. First, let’s create two Streams in different ways:
Stream<Integer> normalStream = Stream.of(1, 2, 3, 4, 5);
IntStream intStreamByRange = IntStream.range(1, 6);
Next, we’d execute the same routine on the two Streams above:
STREAM.peek(add to a result list)
.sorted()
.findFirst();
So, we invoke three methods on each Stream:
- first – invoke the peek() method to collect processed elements to a result list
- then – sort the elements
- finally – take the first element from the Stream
As the two Streams contain the same integer elements, we’d think after the executions, the two result lists should also contain the same integers. So next, let’s write a test to check if it produces the result we expect:
List<Integer> normalStreamPeekResult = new ArrayList<>();
List<Integer> intStreamPeekResult = new ArrayList<>();
// First, the regular Stream
normalStream.peek(normalStreamPeekResult::add)
.sorted()
.findFirst();
assertEquals(Arrays.asList(1, 2, 3, 4, 5), normalStreamPeekResult);
// Then, the IntStream
intStreamByRange.peek(intStreamPeekResult::add)
.sorted()
.findFirst();
assertEquals(Arrays.asList(1), intStreamPeekResult);
After the execution, it turns out that the result list filled by normalStream.peek() contains all integer elements. However, the list filled by intStreamByRange.peek() has only one element.
Next, let’s figure out why it works like that.
3. Streams Are Lazy
Before we explain why the two Streams produced different result lists in the earlier test, let’s understand that Java Streams are lazy by design.
The “lazy” means that Streams only perform the desired operations when they are told to produce a result. In other words, the intermediate operations on a Stream aren’t executed until a terminal operation is performed. This lazy behavior can be an advantage since it allows for more efficient processing and prevent unnecessary computations.
To understand this lazy behavior quickly, let’s temporarily get rid of the sort() method call from our previous test and rerun it:
List<Integer> normalStreamPeekResult = new ArrayList<>();
List<Integer> intStreamPeekResult = new ArrayList<>();
// First, the regular Stream
normalStream.peek(normalStreamPeekResult::add)
.findFirst();
assertEquals(Arrays.asList(1), normalStreamPeekResult);
// Then, the IntStream
intStreamByRange.peek(intStreamPeekResult::add)
.findFirst();
assertEquals(Arrays.asList(1), intStreamPeekResult);
Both Streams have filled only the first element in the corresponding result list this time. This is because the findFirst() method is the terminal operation, requiring only one element – the first one.
Now that we understand Streams are lazy, next, let’s figure out why the two result lists are different when the sorted() method joins the party.
4. Calling sorted()Â May Turn the Stream Into “Eager”
First, let’s take a look at the Stream initialized by Stream.of(). The terminal operation findFirst() only requires the first integer in the Stream. But it’s the first one after the sorted() operation.
We know that we must traverse all integers to sort them. Therefore, calling sorted() has turned the Stream into “eager.” So, the peek() method gets called on every element.
On the other hand, IntStream.range() returns a sequentially-ordered IntStream. That’s to say, the input of the IntStream object is already sorted. Furthermore, when it sorts an already sorted input, Java applies the optimization to make the sorted() operation no-op. Therefore, we still have only one element in the result list.
Next, let’s see another example of a Stream based on TreeSet:
List<String> peekResult = new ArrayList<>();
TreeSet<String> treeSet = new TreeSet<>(Arrays.asList("CCC", "BBB", "AAA", "DDD", "KKK"));
treeSet.stream()
.peek(peekResult::add)
.sorted()
.findFirst();
assertEquals(Arrays.asList("AAA"), peekResult);
We know that TreeSet is a sorted collection. Therefore, we see the peekResult list contains only one string, although we’ve called sorted().
5. Conclusion
In this article, we took Stream.of() and IntStream.range() as examples to understand calling sorted() may turn a Stream from “lazy” to “eager”.
As usual, all code snippets presented in the article are available over on GitHub.
