¿Por qué Stream <T> no implementa Iterable <T>?

En Java 8 tenemos la clase Stream <T> , que curiosamente tiene un método

Iterator<T> iterator()

Por lo tanto, es de esperar que implemente la interfaz Iterable <T> , que requiere exactamente este método, pero ese no es el caso.

Cuando quiero iterar sobre un Stream usando un bucle foreach, tengo que hacer algo como

public static Iterable<T> getIterable(Stream<T> s) {
    return new Iterable<T> {
        @Override
        public Iterator<T> iterator() {
            return s.iterator();
        }
    };
}

for (T element : getIterable(s)) { ... }

¿Me estoy perdiendo de algo?

La gente ya ha preguntado lo mismo en la lista de correo ☺. La razón principal es que Iterable también tiene una semántica repetible, mientras que Stream no lo es.

Creo que la razón principal es que Iterableimplica la reutilización, mientras que Streames algo que solo se puede usar una vez, más como un Iterator.

Si se Streamextiende Iterable, el código existente podría sorprenderse cuando recibe un Iterablemensaje que se lanza por Exceptionsegunda vez for (element : iterable).

Para convertir un Streama un Iterable, puedes hacer

Stream<X> stream = null;
Iterable<X> iterable = stream::iterator

Para pasar Streama un método que espera Iterable,

void foo(Iterable<X> iterable)

simplemente

foo(stream::iterator) 

sin embargo, probablemente se ve divertido; podría ser mejor ser un poco más explícito

foo( (Iterable<X>)stream::iterator );

Me gustaría señalar que StreamEx implementa Iterable(y Stream), así como una gran cantidad de otras funcionalidades inmensamente increíbles que faltan Stream.

Puede usar una secuencia en un forbucle de la siguiente manera:

Stream<T> stream = ...;

for (T x : (Iterable<T>) stream::iterator) {
    ...
}

(Ejecute este fragmento aquí )

(Esto utiliza una conversión de interfaz funcional Java 8).

(Esto está cubierto en algunos de los comentarios anteriores (por ejemplo, Aleksandr Dubinsky ), pero quería sacarlo en una respuesta para hacerlo más visible).

kennytm describió por qué no es seguro tratar un Streamcomo un Iterable, y Zhong Yu ofreció una solución alternativa que permite usar un Streamcomo en Iterable, aunque de manera insegura. Es posible obtener lo mejor de ambos mundos: un reutilizable Iterablede uno Streamque cumpla con todas las garantías hechas por la Iterableespecificación.

Nota: SomeTypeno es un parámetro de tipo aquí; debe reemplazarlo con un tipo adecuado (por ejemplo, String) o recurrir a la reflexión

Stream<SomeType> stream = ...;
Iterable<SomeType> iterable = stream.collect(toList()):

Hay una gran desventaja:

Los beneficios de la iteración perezosa se perderán. Si planeaba iterar inmediatamente sobre todos los valores en el hilo actual, cualquier sobrecarga será insignificante. Sin embargo, si planeaba iterar solo parcialmente o en un hilo diferente, esta iteración inmediata y completa podría tener consecuencias no deseadas.

La gran ventaja, por supuesto, es que puede reutilizar Iterable, mientras (Iterable<SomeType>) stream::iteratorque solo permitiría un solo uso. Si el código de recepción iterará en la colección varias veces, esto no solo es necesario, sino que probablemente sea beneficioso para el rendimiento.

Streamno implementa Iterable. La comprensión general de Iterablees todo lo que se puede repetir, a menudo una y otra vez. Streampuede no ser rejugable

La única solución que se me ocurre, en la que también se puede reproducir un iterable basado en una secuencia, es volver a crear la secuencia. Estoy usando un Suppliersiguiente para crear una nueva instancia de transmisión, cada vez que se crea un nuevo iterador.

    Supplier<Stream<Integer>> streamSupplier = () -> Stream.of(10);
    Iterable<Integer> iterable = () -> streamSupplier.get().iterator();
    for(int i : iterable) {
        System.out.println(i);
    }
    // Can iterate again
    for(int i : iterable) {
        System.out.println(i);
    }

Si no le importa usar bibliotecas de terceros, cyclops-react define un Stream que implementa Stream e Iterable y que también se puede volver a reproducir (resolviendo el problema descrito por kennytm ).

 Stream<String> stream = ReactiveSeq.of("hello","world")
                                    .map(s->"prefix-"+s);

o: -

 Iterable<String> stream = ReactiveSeq.of("hello","world")
                                      .map(s->"prefix-"+s);

 stream.forEach(System.out::println);
 stream.forEach(System.out::println);

[Divulgación Soy el desarrollador principal de cyclops-react]

No es perfecto, pero funcionará:

iterable = stream.collect(Collectors.toList());

No es perfecto, ya que se ha podido recuperar todos los elementos de la corriente y ponerlos en que List, lo que no es exactamente lo que Iterabley Streamestán a punto. Se supone que son flojos .

Puede iterar sobre todos los archivos en una carpeta usando Stream<Path>así:

Path path = Paths.get("...");
Stream<Path> files = Files.list(path);

for (Iterator<Path> it = files.iterator(); it.hasNext(); )
{
    Object file = it.next();

    // ...
}