Stream inherits an iterator() method to produce an Iterator.
But I need an Iterable rather than an Iterator.
For example, given this string:
String input = "this\n" + "that\n" + "the_other"; …I need to pass those parts of string as an Iterable to a specific library. Calling input.lines() yields a Stream. So I would be set if I could make that Stream into a Iterable of its elements.
As explained in Why does Stream<T> not implement Iterable<T>?, an Iterable bears the expectation to be able to provide an Iterator more than once, which a Stream can’t fulfill. So while you can create an Iterable out of a Stream for an ad-hoc use, you have to be careful about whether attempts to iterate it multiple times could exist.
Since you said, “I need to pass those parts of string as an Iterable to a specific library”, there is no general solution as the code using the Iterable is outside your control.
But if you are the one who creates the stream, it is possible to create a valid Iterable which will simply repeat the stream construction every time an Iterator is requested:
Iterable<String> lines = () -> "this\nthat\nthe_other".lines().iterator(); This fulfills the expectation of supporting an arbitrary number of iterations, while not consuming more resources than a single stream when being traversed only once.
for(var s: lines) System.out.println(s); lines.forEach(System.out::println); System.out.println(String.join("\n", lines)); 
Iterable<String> lines = "this\nthat\nthe_other".lines()::iterator; this is one of those rare cases where a method reference is not the same as a lambda and in fact would have undesired effect.
expression::name are never the same as a lambda expressions, not even for System.out::println. But here, we have one of the cases where it mattersstream::iterator and () -> stream.iterator(). In fact, my answer precisely said, there there is no general solution for converting an existing stream to a valid iterable that allows multiple iterations. Repeating the stream construction every time an iterator is requested, i.e. here it means calling lines() every time, is what makes the difference.expression::name means “evaluate expression once and capture the result”, whereas () -> expression.name(…) means “evaluate expression each time the function body is evaluated”. The differences are tiny when “expression” is just a local variable, but even then, it’s different, i.e. stream::iterator will behave different than () -> stream.iterator() when stream is null. So my statement still holds, expression::name is always different to a lambda expression, the question is, how much does it matter for my specific use case.
Supplier<Stream<T>> then you could create an Iterable<T> from that, but I think the use would be niche.Just cast, no need to convert.
Cast Stream<String>::iterator to Iterable<String>.
CAUTION See Answer by Holger explaining dangers of using a stream-backed Iterable.
Yes, you can make an Iterable from a Stream.
The solution is simple, but not obvious. See this post on Maurice Naftalin's Lambda FAQ.
The signature of the iterator method of BaseStream (superclass of Stream) returning a Iterator matches the only method of the functional interface Iterable, so the method reference Stream<T>::iterator can be used as an instance of Iterable<T>. (The fact that both methods have the same name is coincidental.)
Make your input.
String input = "this\n" + "that\n" + "the_other"; Stream<String> stream = input.lines() ; Use the method reference to generate a Iterable<String>.
Iterable< String > iterable = stream::iterator; Test the results.
for ( String s : iterable ) { System.out.println( "s = " + s ); } See this code run live at IdeOne.com.
s = this
s = that
s = the_other
CAVEAT Beware of the risk of stream-backed Iterable. Explained in the correct Answer by Holger.
Stream<String> because stream::iterator isn't of type Stream<String>.
Iterable through a method reference; the (Iterable<String>) just tells the compiler which functional interface is the target.
(Iterable<String>)()->stream.iterator() or even more explicitly new Iterable<String>(){ public Iterator<String> iterator(){ return stream.iterator();}. So you are not casting a Stream to Iterable, which would fail.(Iterator<String>)"one\ntwo".lines(); produces. Exception in thread "main" java.lang.ClassCastException: class java.util.stream.ReferencePipeline$Head cannot be cast to class java.util.Iterator thats from openjdk version "11.0.6" 2020-01-14. Your code compiles but throws an exception. I don't know what you're actually running.