Warum implementiert Stream <T> Iterable <T> nicht?

In Java 8 haben wir die Klasse Stream <T> , die seltsamerweise eine Methode hat

Iterator<T> iterator()

Sie würden also erwarten, dass die Schnittstelle Iterable <T> implementiert wird , was genau diese Methode erfordert, aber das ist nicht der Fall.

Wenn ich mit einer foreach-Schleife über einen Stream iterieren möchte, muss ich so etwas tun

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

Vermisse ich hier etwas?

Die Leute haben das schon auf der Mailingliste gefragt ☺. Der Hauptgrund dafür ist, dass Iterable auch eine wiederholbare Semantik hat, Stream jedoch nicht.

Ich denke, der Hauptgrund ist, dass Iterabledies die Wiederverwendbarkeit impliziert, während Streamdies nur einmal verwendet werden kann - eher wie ein Iterator.

Wenn Streamverlängert Iterabledann könnten vorhandenen Code überrascht sein , wenn er erhält ein Iterable, der eine wirft Exceptiondas zweite Mal , wenn sie tun for (element : iterable).

Um ein Streamin ein zu konvertieren Iterable, können Sie tun

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

Um a Streaman eine Methode zu übergeben, die erwartet Iterable,

void foo(Iterable<X> iterable)

einfach

foo(stream::iterator) 

aber es sieht wahrscheinlich lustig aus; es könnte besser sein, ein bisschen expliziter zu sein

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

Ich möchte darauf hinweisen, dass StreamExdies Iterable(und Stream) implementiert , sowie eine Vielzahl anderer immens beeindruckender Funktionen, die fehlen Stream.

Sie können einen Stream in einer forSchleife wie folgt verwenden:

Stream<T> stream = ...;

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

(Führen Sie dieses Snippet hier aus )

(Dies verwendet eine Java 8-Funktionsschnittstelle.)

(Dies wird in einigen der obigen Kommentare behandelt (z. B. Aleksandr Dubinsky ), aber ich wollte es in eine Antwort ziehen, um es sichtbarer zu machen.)

kennytm beschrieb, warum es unsicher ist, a Streamals zu behandeln Iterable, und Zhong Yu bot eine Problemumgehung an , die die Verwendung eines Streamas in ermöglicht Iterable, wenn auch auf unsichere Weise. Es ist möglich , das Beste aus beiden Welten zu bekommen: ein wiederverwendbaren Iterablevon einem Stream, der durch die aus allen Garantien erfüllt IterableSpezifikation.

Hinweis: SomeTypeist hier kein Typparameter - Sie müssen ihn durch einen geeigneten Typ (z. B. String) ersetzen oder auf Reflexion zurückgreifen

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

Es gibt einen großen Nachteil:

Die Vorteile der verzögerten Iteration gehen verloren. Wenn Sie vorhaben, alle Werte im aktuellen Thread sofort zu durchlaufen, ist der Overhead vernachlässigbar. Wenn Sie jedoch nur teilweise oder in einem anderen Thread iterieren möchten, kann diese sofortige und vollständige Iteration unbeabsichtigte Folgen haben.

Der große Vorteil ist natürlich, dass Sie das wiederverwenden können Iterable, während (Iterable<SomeType>) stream::iteratores nur eine einmalige Verwendung erlauben würde. Wenn der empfangende Code mehrmals über die Sammlung iteriert, ist dies nicht nur erforderlich, sondern wahrscheinlich auch vorteilhaft für die Leistung.

Streamnicht implementiert Iterable. Das allgemeine Verständnis von Iterableist alles, worauf oft wiederholt werden kann. Streamist möglicherweise nicht wiederholbar.

Die einzige Problemumgehung, die ich mir vorstellen kann, wenn ein auf einem Stream basierendes Iterable ebenfalls wiedergegeben werden kann, besteht darin, den Stream neu zu erstellen. Ich verwende Supplierunten, um eine neue Instanz des Streams zu erstellen, jedes Mal, wenn ein neuer Iterator erstellt wird.

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

Wenn es Ihnen nichts ausmacht, Bibliotheken von Drittanbietern zu verwenden, definiert cyclops-react einen Stream, der sowohl Stream als auch Iterable implementiert und auch wiedergegeben werden kann (Lösung des beschriebenen Kennytm- Problems ).

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

oder :-

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

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

[Offenlegung Ich bin der Hauptentwickler von Cyclops-React]

Nicht perfekt, wird aber funktionieren:

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

Nicht perfekt, weil es alle Elemente aus dem Stream abruft und in das einfügt List, was nicht genau das ist Iterableund worum Streames geht. Sie sollen faul sein .

Sie können alle Dateien in einem Ordner folgendermaßen durchlaufen Stream<Path>:

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

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

    // ...
}