Por que o Stream <T> não implementa o Iterable <T>?

No Java 8, temos a classe Stream <T> , que curiosamente tem um método

Iterator<T> iterator()

Então, você esperaria implementar a interface Iterable <T> , que requer exatamente esse método, mas esse não é o caso.

Quando quero iterar em um Stream usando um loop foreach, tenho que fazer 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)) { ... }

Estou faltando alguma coisa aqui?

As pessoas já perguntaram o mesmo na lista de discussão ☺. O principal motivo é que o Iterable também possui uma semântica reiterável, enquanto o Stream não.

Eu acho que a principal razão é que isso Iterableimplica reutilização, enquanto que Streamé algo que só pode ser usado uma vez - mais como um Iterator.

Se Streamestendido Iterable, o código existente pode ser surpreendido ao receber um Iterableque é emitido Exceptionpela segunda vez for (element : iterable).

Para converter um Streampara um Iterable, você pode fazer

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

Para passar a Streampara um método que espera Iterable,

void foo(Iterable<X> iterable)

simplesmente

foo(stream::iterator) 

no entanto, provavelmente parece engraçado; pode ser melhor ser um pouco mais explícito

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

Gostaria de salientar que StreamEximplementa Iterable(e Stream), bem como uma série de outras funcionalidades imensamente impressionantes ausentes Stream.

Você pode usar um fluxo em um forloop da seguinte maneira:

Stream<T> stream = ...;

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

(Execute este trecho aqui )

(Isso usa uma interface funcional Java 8 convertida.)

(Isso é abordado em alguns dos comentários acima (por exemplo, Aleksandr Dubinsky ), mas eu queria extraí-lo em uma resposta para torná-lo mais visível.)

O kennytm descreveu por que não é seguro tratar um Streamcomo um Iterablee Zhong Yu oferece uma solução alternativa que permite o uso de um Streamcomo Iterable, embora de maneira insegura. É possível obter o melhor dos dois mundos: a reutilizáveis Iterablea partir de um Streamque atenda todas as garantias feitas pela Iterableespecificação.

Nota: SomeTypenão é um parâmetro de tipo aqui - você precisa substituí-lo por um tipo adequado (por exemplo, String) ou recorrer à reflexão

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

Há uma grande desvantagem:

Os benefícios da iteração lenta serão perdidos. Se você planejou iterar imediatamente todos os valores no encadeamento atual, qualquer sobrecarga será insignificante. No entanto, se você planejou iterar apenas parcialmente ou em um encadeamento diferente, essa iteração imediata e completa pode ter consequências indesejadas.

A grande vantagem, é claro, é que você pode reutilizar o Iterable, enquanto (Iterable<SomeType>) stream::iteratorisso permitiria apenas um único uso. Se o código de recebimento estiver repetindo a coleção várias vezes, isso não é apenas necessário, mas provavelmente benéfico para o desempenho.

Streamnão implementa Iterable. O entendimento geral de Iterablequalquer coisa que possa ser repetido, muitas e muitas vezes. Streampode não ser reproduzível.

A única solução alternativa em que consigo pensar, em que uma iterável baseada em um fluxo também é reproduzível, é recriar o fluxo. Estou usando um Supplierabaixo para criar uma nova instância do fluxo, sempre que um novo iterador é criado.

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

Se você não se importa em usar bibliotecas de terceiros, o cyclops- react define um Stream que implementa Stream e Iterable e também é reproduzível (resolvendo o problema descrito pelo kennytm ).

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

ou: -

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

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

[Divulgação Sou o principal desenvolvedor do cyclops-react]

Não é perfeito, mas funcionará:

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

Não é perfeito porque ele buscará todos os itens do fluxo e os colocará nele List, o que não é exatamente o que é Iterablee o que Streamé. Eles deveriam ser preguiçosos .

Você pode iterar sobre todos os arquivos em uma pasta usando o Stream<Path>seguinte:

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

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

    // ...
}