Dlaczego Stream <T> nie implementuje Iterable <T>?

W Javie 8 mamy klasę Stream <T> , która, co ciekawe, ma metodę

Iterator<T> iterator()

Można się więc spodziewać, że zaimplementuje interfejs Iterable <T> , który wymaga dokładnie tej metody, ale tak nie jest.

Kiedy chcę iterować po strumieniu za pomocą pętli foreach, muszę zrobić coś takiego

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

Czy coś mi umyka?

Ludzie pytali już o to samo na liście mailingowej ☺. Głównym powodem jest to, że Iterable ma również powtarzalną semantię, podczas gdy Stream nie.

Myślę, że głównym powodem jest to, że Iterableoznacza to możliwość ponownego użycia, podczas gdy Streamjest to coś, co można wykorzystać tylko raz - bardziej jak Iterator.

Jeśli zostanie Streamrozszerzony, Iterableistniejący kod może być zaskoczony, gdy otrzyma komunikat, Iterablektóry generuje Exceptionpo raz drugi for (element : iterable).

Aby przekonwertować Streamna a Iterable, możesz to zrobić

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

Aby przekazać Streammetodę, która oczekuje Iterable:

void foo(Iterable<X> iterable)

po prostu

foo(stream::iterator) 

jednak prawdopodobnie wygląda śmiesznie; może lepiej być trochę bardziej wyraźnym

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

Chciałbym zauważyć, że StreamEximplementuje Iterable(i Stream), a także wiele innych niesamowicie niesamowitych funkcji, których brakuje Stream.

Możesz użyć strumienia w forpętli w następujący sposób:

Stream<T> stream = ...;

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

(Uruchom ten fragment tutaj )

(Używa to obsady interfejsu Java 8).

(Jest to opisane w niektórych powyższych komentarzach (np. Aleksandr Dubinsky ), ale chciałem wyciągnąć je w odpowiedzi, aby było bardziej widoczne.)

kennytm opisał, dlaczego niebezpieczne jest traktowanie Streamjako „a” Iterable, a Zhong Yu zaproponował obejście, które pozwala na użycie „tak Streamjak” Iterable, choć w niebezpieczny sposób. Jest to możliwe, aby uzyskać najlepsze z obu światów: wielokrotnego użytku Iterablez punktu A Stream, który spełnia wszelkie gwarancje dokonane przez Iterablespecyfikację.

Uwaga: SomeTypenie jest tutaj parametrem typu - należy go zastąpić odpowiednim typem (np. String) Lub zastosować odbicie

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

Jest jedna poważna wada:

Korzyści z leniwej iteracji zostaną utracone. Jeśli planujesz natychmiastowe iterowanie wszystkich wartości w bieżącym wątku, wszelkie koszty ogólne będą nieistotne. Jeśli jednak planujesz iterować tylko częściowo lub w innym wątku, ta natychmiastowa i pełna iteracja może mieć niezamierzone konsekwencje.

Dużą zaletą jest oczywiście to, że można ponownie użyć Iterable, podczas gdy (Iterable<SomeType>) stream::iteratorzezwala się tylko na jedno użycie. Jeśli kod odbierający będzie wielokrotnie iterował kolekcję, jest to nie tylko konieczne, ale prawdopodobnie korzystne dla wydajności.

Streamnie implementuje Iterable. Ogólne zrozumienie Iterablejest wszystkim, co można powtarzać, często od nowa. Streammogą nie być odtwarzane.

Jedynym sposobem, w jaki mogę wymyślić, gdzie można odtworzyć iterację opartą na strumieniu, jest odtworzenie strumienia. Używam Supplierponiżej, aby utworzyć nową instancję strumienia, za każdym razem, gdy tworzony jest nowy iterator.

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

Jeśli nie przeszkadza przy użyciu bibliotek stron trzecich cyklop reagują definiuje Stream, który implementuje zarówno Stream i iterable i replayable zbyt (rozwiązując problem kennytm opisane ).

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

lub:

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

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

[Ujawnienie Jestem wiodącym twórcą Cyclops-reag]

Nie idealnie, ale zadziała:

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

Nie idealne, ponieważ będzie pobrać wszystkie elementy ze strumienia i umieścić je w to List, co nie jest dokładnie to, co Iterablei Streamchodzi. Powinny być leniwi .

Możesz iterować wszystkie pliki w folderze, korzystając z Stream<Path>tego:

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

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

    // ...
}