Working With Empty Stream in Java

1. Overview

In this short tutorial, we’ll have a quick look at intermediate and terminal operations in Java Streams, some of the ways of creating an empty Stream, and how to check for an empty Stream.

2. Streams and Stream Operations

The Stream API is one of the major features of Java 8. A Stream is a sequence of elements on which we can iterate and perform operations.

Stream operations are specifically divided into two types – intermediate and terminal. The intermediate and terminal operations can be chained together to form a stream pipeline.

Terminal operations, as the name suggests, appear at the end of a stream pipeline and return a result such as distinct() or create a side effect such as forEach().

On the other hand, intermediate operations, such as sorted(), transform a Stream into another Stream. Therefore, we can chain multiple intermediate operations.

Any of the terminal or intermediate operations don’t actually change the source of the Stream but produce a result. Also, the intermediate operations are performed in a lazy manner; The computations are performed only after initiating a terminal operation.

Let’s look at an example:

Stream<Integer> numbers = Stream.of(1, 2, 3, 4, 5, 6);

int sumOfEvenNumbers = numbers
  .filter(number -> number%2 == 0)
  .reduce(0, Integer::sum);

Assert.assertEquals(sumOfEvenNumbers, 12);

Here, we have created a Stream of integers. We’ve used an intermediate operation filter() that creates another Stream of even numbers. Finally, we’ve used the terminal operation reduce() to get the sum of all the even numbers.

3. Creating an Empty Stream in Java

Sometimes, we may need to pass a Stream as a parameter to methods or return one from a method. An empty Stream is useful to handle NullPointerExceptions. Moreover, some of the Stream operations, such as findFirst(), findAny(), min(), and max(), check for empty Stream and return the results accordingly.

There are multiple ways of creating Streams. Consequently, there’re multiple ways to create an empty Stream too.

To start with, we can simply use the empty() method of class Stream:

Stream<String> emptyStream = Stream.empty();

The empty() method returns an empty sequential Stream of type String.

We can also create an empty Stream of any type using the of() method. The of() method returns a sequential ordered Stream containing the elements that are passed as parameters to it. If we don’t pass any parameter, it returns an empty Stream:

Stream<String> emptyStr = Stream.of();

Similarly, we can create a Stream of primitive types using IntStream:

IntStream intStream = IntStream.of(new int[]{});

The Arrays class has a method stream() that accepts an array as a parameter and returns a Stream of the same type as that of the parameter. We can use this to create an empty Stream by passing an empty array as a parameter:

IntStream emptyIntStream = Arrays.stream(new int[]{});

Finally, we can use the stream() method of a Collection such as a List or Set to create an empty Stream. An empty collection would create an empty Stream:

Stream<Integer> emptyIntStream = new ArrayList<Integer>().stream();

4. Checking for an Empty Stream

We can check for an empty Stream by simply using one of the short-circuiting terminal operations such as findFirst() or findAny():

Stream<String> emptyStream = Stream.empty();
assertTrue(emptyStream.findAny().isEmpty());

Here, findFirst() returns an empty Optional if the stream is empty. We then check for the presence of a value in the Optional. Since the Stream is empty, no value is present in the Optional, and it returns false.

However, we must remember that we can operate upon a Stream only once. If we reuse the Stream, we may encounter an IllegalStateException saying:

IllegalStateException: stream has already been operated upon or closed.

Therefore, we’re only allowed to perform a single operation that consumes a Stream. If we want to reuse the Stream, we must handle this IllegalStateException.

To solve this problem, we can create a new Stream using the Supplier functional interface whenever we need to check for its emptiness:

Supplier<Stream<Integer>> streamSupplier = Stream::of;

Optional<Integer> result1 = streamSupplier.get().findAny();
assertTrue(result1.isEmpty());
Optional<Integer> result2 = streamSupplier.get().findFirst();
assertTrue(result2.isEmpty());

Here, we’ve first defined an empty Stream. Then we’ve created a streamSupplier object with the type Stream<Integer>. Thus, each call to the get() method returns a new empty Stream object on which we can safely perform another Stream operation.

5. Conclusion

In this quick article, we saw some of the ways of creating empty Streams in Java. We also explored how to check if a Stream is empty and how to reuse the Stream multiple times while avoiding the famous IllegalStateException that is thrown when the Stream is already closed or operated upon.