Understanding the Difference Between Stream.of() and IntStream.range()

Last updated: March 7, 2025

Written by: Kai Yuan

Reviewed by: Eric Martin

Java Streams

Java Stream Basics

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

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().