Convertir Iterable a Stream usando Java 8 JDK

Tengo una interfaz que vuelve java.lang.Iterable<T>.

Me gustaría manipular ese resultado utilizando la API Java 8 Stream.

Sin embargo, Iterable no puede "transmitir".

¿Alguna idea de cómo usar Iterable como Stream sin convertirlo en List?

Hay una respuesta mucho mejor que usar spliteratorUnknownSizedirectamente, lo cual es más fácil y obtiene un mejor resultado. Iterabletiene un spliterator()método, por lo que debe usarlo para obtener su spliterator. En el peor de los casos, es el mismo código (la implementación predeterminada lo usa spliteratorUnknownSize), pero en el caso más común, donde Iterableya es una colección, obtendrá un mejor spliterator y, por lo tanto, un mejor rendimiento de transmisión (tal vez incluso un buen paralelismo). También es menos código:

StreamSupport.stream(iterable.spliterator(), false)
             .filter(...)
             .moreStreamOps(...);

Como puede ver, obtener una transmisión de un Iterable(vea también esta pregunta ) no es muy doloroso.

Si puede usar la biblioteca Guava, desde la versión 21, puede usar

Streams.stream(iterable)

Puede crear fácilmente Streamun Iterableo Iterator:

public static <T> Stream<T> stream(Iterable<T> iterable) {
    return StreamSupport.stream(
        Spliterators.spliteratorUnknownSize(
            iterable.iterator(),
            Spliterator.ORDERED
        ),
        false
    );
}

Me gustaría sugerir el uso de la biblioteca JOOL , oculta la magia de spliterator detrás de la llamada Seq.seq (iterable) y también proporciona un montón de funcionalidades adicionales útiles.

Entonces, como otra respuesta mencionó, Guava tiene soporte para esto al usar:

Streams.stream(iterable);

Quiero resaltar que la implementación hace algo ligeramente diferente a otras respuestas sugeridas. Si el Iterablees de tipo, Collectionlo echan.

public static <T> Stream<T> stream(Iterable<T> iterable) {
  return (iterable instanceof Collection)
    ? ((Collection<T>) iterable).stream()
    : StreamSupport.stream(iterable.spliterator(), false);
}

public static <T> Stream<T> stream(Iterator<T> iterator) {
  return StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(iterator, 0),
    false
  );
}

He creado esta clase:

public class Streams {
    /**
     * Converts Iterable to stream
     */
    public static <T> Stream<T>  streamOf(final Iterable<T> iterable) {
        return toStream(iterable, false);
    }

    /**
     * Converts Iterable to parallel stream
     */
    public static <T> Stream<T> parallelStreamOf(final Iterable<T> iterable) {
        return toStream(iterable, true);
    }

    private static <T> Stream<T> toStream(final Iterable<T> iterable, final boolean isParallel) {
        return StreamSupport.stream(iterable.spliterator(), isParallel);
    }
}

Creo que es perfectamente legible porque no tienes que pensar en spliterators y booleans (isParallel).

Una solución muy simple para este problema es crear una Streamable<T>interfaz Iterable<T>que se extienda y que contenga un default <T> stream()método.

interface Streamable<T> extends Iterable<T> {
    default Stream<T> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}

Ahora cualquiera de tus Iterable<T>correos electrónicos se puede hacer trivialmente en streaming simplemente declarándolos en implements Streamable<T>lugar de hacerlo Iterable<T>.

Si utiliza Vavr (anteriormente conocido como Javaslang), esto puede ser tan fácil como:

Iterable i = //...
Stream.ofAll(i);

Otra forma de hacerlo, con Java 8 y sin bibliotecas externas:

Stream.concat(collectionA.stream(), collectionB.stream())
      .collect(Collectors.toList())