Perché Stream <T> non implementa Iterable <T>?

In Java 8 abbiamo la classe Stream <T> , che curiosamente ha un metodo

Iterator<T> iterator()

Quindi ti aspetteresti che implementa l'interfaccia Iterable <T> , che richiede esattamente questo metodo, ma non è così.

Quando voglio iterare su uno Stream usando un ciclo foreach, devo fare qualcosa del genere

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)) { ... }

Mi sto perdendo qualcosa qui?

Le persone hanno già chiesto lo stesso sulla mailing list ☺. Il motivo principale è Iterable ha anche una semantica reiterabile, mentre Stream no.

Penso che il motivo principale sia che Iterableimplica la riusabilità, mentre Streamè qualcosa che può essere usato solo una volta - più come un Iterator.

Se Streamesteso, il Iterablecodice esistente potrebbe essere sorpreso quando riceve un oggetto Iterableche viene lanciato una Exceptionseconda volta for (element : iterable).

Per convertire un Streamin un Iterable, puoi farlo

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

Per passare Streama un metodo che prevede Iterable,

void foo(Iterable<X> iterable)

semplicemente

foo(stream::iterator) 

tuttavia probabilmente sembra divertente; potrebbe essere meglio essere un po 'più esplicito

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

Vorrei sottolineare che StreamEximplementa Iterable(e Stream), oltre a una serie di altre funzionalità immensamente fantastiche che mancano Stream.

Puoi usare uno Stream in un forciclo come segue:

Stream<T> stream = ...;

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

(Esegui questo frammento qui )

(Questo utilizza un cast di interfaccia funzionale Java 8).

(Questo è coperto in alcuni dei commenti sopra (ad esempio Aleksandr Dubinsky ), ma volevo estrarlo in una risposta per renderlo più visibile.)

kennytm ha descritto perché non è sicuro trattare un Streamcome an Iterablee Zhong Yu ha offerto una soluzione alternativa che consente di utilizzare un Streamas in Iterable, anche se in modo non sicuro. È possibile ottenere il meglio da entrambi i mondi: un riutilizzabile Iterableda uno Streamche soddisfa tutte le garanzie fornite dalle Iterablespecifiche.

Nota: SomeTypenon è un parametro di tipo qui - è necessario sostituirlo con un tipo corretto (ad es. String) O ricorrere alla riflessione

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

C'è un grosso svantaggio:

I benefici dell'iterazione lenta andranno persi. Se hai pianificato di iterare immediatamente su tutti i valori nel thread corrente, qualsiasi overhead sarà trascurabile. Tuttavia, se hai pianificato di iterare solo parzialmente o in un thread diverso, questa iterazione immediata e completa potrebbe avere conseguenze non intenzionali.

Il grande vantaggio, ovviamente, è che puoi riutilizzare il Iterable, mentre (Iterable<SomeType>) stream::iteratorconsentirebbe un solo uso. Se il codice di ricezione ripeterà più volte la raccolta, questo non è solo necessario, ma probabilmente vantaggioso per le prestazioni.

Streamnon implementa Iterable. La comprensione generale di Iterabletutto ciò che può essere ripetuto, spesso ancora e ancora. Streampotrebbe non essere riproducibile.

L'unica soluzione che mi viene in mente, in cui è riproducibile anche un iterabile basato su uno stream, è ricreare lo stream. Sto usando un Suppliersotto per creare una nuova istanza di stream, ogni volta che viene creato un nuovo iteratore.

    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 non ti dispiace usare librerie di terze parti cyclops- reazioni definisce uno Stream che implementa sia Stream che Iterable ed è anche riproducibile (risolvendo il problema descritto da 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);

[Divulgazione Sono lo sviluppatore principale di cyclops-reagire]

Non perfetto, ma funzionerà:

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

Non perfetto perché recupererà tutti gli elementi dallo stream e li inserirà in quello List, che non è esattamente cosa Iterablee di cosa Streamsi tratta. Dovrebbero essere pigri .

Puoi iterare su tutti i file in una cartella usando in Stream<Path>questo modo:

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

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

    // ...
}