Stream to Iterable in Java

1. Introduction

The Java Streams API was introduced in Java 8 and provides functionalities for processing sequences of elements. Streams API supports chaining operations on a Collection of objects in a pipeline in order to produce the desired outcome.

In this tutorial, we’ll look into ways of using a Stream as an Iterable.

2. Iterable and Iterator

Iterable<T> is an interface available since Java 1.5. A class implementing this interface allows the object of the class to be the target of the for-each loop statement. The implementing class doesn’t store any information about its iteration state and should produce a valid Iterator of itself.

The Collection interface extends the Iterable interface, and all concrete implementations of the Collection interface, such as ArrayList or HashSet, produce an iterator by implementing the iterator() method of Iterable. 

The Iterator<T> interface, also part of the Java Collections framework, has been available since Java 1.2. A class implementing an Iterator<T> must provide an implementation of iterating through the collection, such as the ability to move to the next element, check if there are any more elements, or delete the current element from the collection:

public interface Iterator<E> {
    boolean hasNext();
    E next();
    void remove();
}

3. Problem Statement

Now that we have gone through the basics of the Iterator and Iterable interfaces and the role they play, let’s understand the problem statement.

Classes that implement the Collection interface inherently implement the Iterable<T> interface. Streams, on the other hand, are slightly different. Notably, BaseStream<T>, the interface that Stream<T> extends, has a method iterator() but doesn’t implement the Iterable interface.

With this limitation comes the challenge of not being able to use the enhanced for-each loop on a Stream.

We’ll look at some ways to overcome this problem in the following sections and finally touch upon the idea of why Stream, unlike Collection, doesn’t extend the Iterable interface.

4. Convert Stream to Iterable Using iterator() on Stream

The Stream interface’s iterator() method returns an iterator for the elements of the stream. It’s a terminal stream operation:

Iterator<T> iterator();

However, we’d still not be able to use the resulting iterator in the enhanced for-each loop:

private void streamIterator(List<String> listOfStrings) {
    Stream<String> stringStream = listOfStrings.stream();
    // this does not compile
    for (String eachString : stringStream.iterator()) {
        doSomethingOnString(eachString);
    }
}

A “for-each loop” works for an Iterable and not an Iterator, as we saw earlier. To solve this, we cast the iterator into an Iterable instance and then apply our desired for-each loop. The fact that Iterable<T> is a functional interface allows us to write the code using lambda:

for (String eachString : (Iterable<String>) () -> stringStream.iterator()) {
    doSomethingOnString(eachString);
}

We can do a little more refactoring using the method reference approach:

for (String eachString : (Iterable<String>) stringStream::iterator) {
    doSomethingOnString(eachString.toLowerCase());
}

It’s also possible to use a temporary variable, iterableStream, to hold the Iterable before using it in the for-each loop:

Iterable<String> iterableStream = () -> stringStream.iterator();
for (String eachString : iterableStream) {
    doSomethingOnString(eachString, sentence);
}

5. Use Stream in for-each Loop by Converting to a Collection

We discussed above how the Collection interface extends the Iterable interface. We can hence convert a given Stream to a collection and use the result as an Iterable:

for(String eachString : stringStream.collect(Collectors.toList())) {
    doSomethingOnString(eachString);
}

6. Why Stream Doesn’t Implement Iterable

We saw how we could use a Stream as an Iterable. Collections such as Lists and Sets are data structures that store data in them and are intended for use multiple times in their lifetime. These objects are passed along to different methods, undergo change multiple times, and most importantly, are iterated over multiple times.

Streams, on the other hand, are a single-use data structure and hence aren’t designed to be iterated using a for-each loop. Streams are simply not expected to be iterated over and over again and throw an IllegalStateException when the stream is already closed and operated on. Therefore, although Stream provides an iterator() method, it doesn’t extend Iterable.

7. Conclusion

In this article, we looked at different ways a Stream can be used as an Iterable.

We briefly discussed the differences between an Iterable and an Iterator and also why Stream<T> doesn’t implement the Iterable<T> interface.