<T> Akışı neden Tekrarlanabilir <T> uygulamıyor?

Java 8'de , merakla bir yöntemi olan Stream <T> sınıfına sahibiz

Iterator<T> iterator()

Dolayısıyla , tam olarak bu yöntemi gerektiren Yinelenebilir <T> arabirimini uygulamasını beklersiniz , ancak durum böyle değildir.

Bir foreach döngüsü kullanarak bir Stream üzerinde yineleme yapmak istediğimde,

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

Burada bir şey mi eksik?

İnsanlar posta listesinden de aynısını sordular ☺. Ana nedeni, Yinelenebilir de tekrarlanabilir bir semantik var, ancak Stream değil.

Bence asıl neden Iterableyeniden kullanılabilirliği ima ederken Stream, sadece bir kez kullanılabilecek bir şey - daha çok bir Iterator.

Eğer Streamuzatılmışsa, Iterablemevcut kod ikinci kez Iterableattığında mevcut kodu şaşırtabilir .Exceptionfor (element : iterable)

Bir dönüştürmek için Streambir etmek Iterable, yapabileceğiniz

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

Beklenen bir Streamyönteme geçmek için Iterable,

void foo(Iterable<X> iterable)

basitçe

foo(stream::iterator) 

ancak muhtemelen komik görünüyor; biraz daha açık olmak daha iyi olabilir

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

Bunu StreamExuygulamak Iterable(ve Stream) yanı sıra eksik diğer son derece harika işlevsellik bir dizi işaret etmek istiyorum Stream.

Bir akışı bir fordöngüde aşağıdaki gibi kullanabilirsiniz :

Stream<T> stream = ...;

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

( Bu snippet'i burada çalıştırın )

(Bu, Java 8 işlevsel bir arayüz kullanır.)

(Bu, yukarıdaki yorumların bazılarında ele alınmıştır (örneğin, Aleksandr Dubinsky ), ancak daha görünür hale getirmek için bir cevaba çekmek istedim.)

kennytm, neden a Streamolarak davranmanın güvensiz olduğunu açıkladı Iterableve Zhong Yu , güvenli olmayan bir şekilde olsa da, Streamolduğu gibi kullanılmasına izin veren bir geçici çözüm sunduIterable . Yeniden kullanılabilir: Bu iki dünyanın en iyisi almak mümkündür Iterablebir gelen Streamtarafından yapılan tüm garantileri karşıladığını Iterableşartname.

Not: SomeTypeburada bir tür parametresi değildir - uygun bir türle (örn. String) Değiştirmeniz veya yansımaya başvurmanız gerekir

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

Büyük bir dezavantaj var:

Tembel yinelemenin faydaları kaybolacak. Geçerli iş parçacığındaki tüm değerleri hemen yinelemeyi planladıysanız, ek yük ihmal edilebilir. Ancak, yalnızca kısmen veya farklı bir iş parçacığında yinelemeyi planladıysanız, bu anında ve tam yinelemenin istenmeyen sonuçları olabilir.

En büyük avantajı, elbette, sadece tek bir kullanıma izin Iterableverirken , yeniden (Iterable<SomeType>) stream::iteratorkullanabilirsiniz. Alıcı kod, koleksiyon üzerinde birden çok kez yinelenecekse, bu sadece gerekli değil, aynı zamanda performans için de faydalıdır.

Streamuygulanmaz Iterable. Genel anlayışı Iterable, sık sık tekrar tekrar yinelenebilecek her şeydir. Streamtekrar oynatılamayabilir.

Akışı temel alan bir yinelemenin de tekrar oynatılabilir olduğu yerlerde düşünebildiğim tek çözüm, akışı yeniden oluşturmaktır. SupplierYeni bir yineleyici oluşturulduğunda her seferinde yeni bir akış örneği oluşturmak için aşağıdakileri kullanıyorum .

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

Üçüncü taraf kütüphanelerini kullanmanın sakıncası yoksa cyclops-tepki , hem Akışı hem de Yinelenebilir'i uygulayan ve aynı zamanda tekrar oynatılabilen ( açıklanan kennytm sorununu çözen ) bir Akım tanımlar .

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

veya: -

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

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

[Açıklama Ben cyclops-tepki reaksiyonu geliştiricisiyim]

Mükemmel değil, ama işe yarayacak:

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

Mükemmel değil çünkü akıştaki tüm öğeleri alır ve bunlara koyar List, ki bu tam olarak ne olduğu Iterableve Streamhakkında değildir. Tembel olmaları gerekiyordu .

Aşağıdaki Stream<Path>gibi kullanarak bir klasördeki tüm dosyaları yineleyebilirsiniz :

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

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

    // ...
}