Conversão Iterable para Stream usando Java 8 JDK

Eu tenho uma interface que retorna java.lang.Iterable<T>.

Gostaria de manipular esse resultado usando a API Java 8 Stream.

No entanto, o Iterable não pode "transmitir".

Alguma idéia de como usar o Iterable como um fluxo sem convertê-lo em lista?

Há uma resposta muito melhor do que usar spliteratorUnknownSizediretamente, o que é mais fácil e obtém um resultado melhor. Iterabletem um spliterator()método, então você deve usá-lo apenas para obter seu spliterator. Na pior das hipóteses, é o mesmo código (a implementação padrão usa spliteratorUnknownSize), mas no caso mais comum, onde você Iterablejá é uma coleção, você obtém um melhor spliterator e, portanto, melhor desempenho do fluxo (talvez até um bom paralelismo). Também é menos código:

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

Como você pode ver, obter um fluxo de um Iterable(consulte também esta pergunta ) não é muito doloroso.

Se você pode usar a biblioteca Guava, desde a versão 21, você pode usar

Streams.stream(iterable)

Você pode criar facilmente um Streamde um Iterableou Iterator:

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

Eu gostaria de sugerir o uso da biblioteca JOOL , que oculta a mágica do spliterator por trás da chamada Seq.seq (iterável) e também fornece várias funcionalidades úteis adicionais.

Portanto, como outra resposta mencionada, o Guava tem suporte para isso usando:

Streams.stream(iterable);

Quero destacar que a implementação faz algo ligeiramente diferente das outras respostas sugeridas. Se o Iterableé do tipo, Collectioneles o lançam.

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
  );
}

Eu criei esta classe:

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);
    }
}

Eu acho que é perfeitamente legível, porque você não precisa pensar em separadores e booleanos (isParallel).

Uma solução muito simples para esse problema é criar uma Streamable<T>interface Iterable<T>que se estende que contém um default <T> stream()método.

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

Agora, qualquer um dos seus Iterable<T>s pode ser trivialmente tornado estrias apenas declarando-os em implements Streamable<T>vez de Iterable<T>.

Se você usa o Vavr (anteriormente conhecido como Javaslang), isso pode ser tão fácil quanto:

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

Outra maneira de fazer isso, com o Java 8 e sem bibliotecas externas:

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