Mengapa Stream <T> tidak menerapkan Iterable <T>?

Di Java 8 kita memiliki Stream kelas <T> , yang anehnya memiliki metode

Iterator<T> iterator()

Jadi Anda akan mengharapkannya untuk mengimplementasikan antarmuka Iterable <T> , yang membutuhkan metode ini, tapi bukan itu masalahnya.

Ketika saya ingin mengulangi Stream menggunakan loop foreach, saya harus melakukan sesuatu seperti

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

Apakah saya melewatkan sesuatu di sini?

Orang-orang sudah menanyakan hal yang sama di milis ☺. Alasan utamanya adalah Iterable juga memiliki semantik yang dapat diulang kembali, sedangkan Stream tidak.

Saya pikir alasan utama adalah yang Iterablemenyiratkan dapat digunakan kembali, sedangkan Streamadalah sesuatu yang hanya dapat digunakan sekali - lebih seperti sebuah Iterator.

Jika Streamdiperpanjang Iterablemaka kode yang ada mungkin akan terkejut ketika menerima Iterableyang melempar yang Exceptionkedua kalinya mereka lakukan for (element : iterable).

Untuk mengonversi a Streammenjadi Iterable, Anda dapat melakukannya

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

Untuk meneruskan Streammetode yang diharapkan Iterable,

void foo(Iterable<X> iterable)

secara sederhana

foo(stream::iterator) 

namun mungkin terlihat lucu; mungkin lebih baik sedikit lebih eksplisit

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

Saya ingin menunjukkan bahwa StreamExtidak mengimplementasikan Iterable(dan Stream), serta sejumlah fungsi luar biasa lainnya yang hilang Stream.

Anda dapat menggunakan Stream dalam satu forloop sebagai berikut:

Stream<T> stream = ...;

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

(Jalankan cuplikan ini di sini )

(Ini menggunakan pemeran antarmuka fungsional Java 8.)

(Ini tercakup dalam beberapa komentar di atas (misalnya Aleksandr Dubinsky ), tetapi saya ingin menariknya ke dalam jawaban untuk membuatnya lebih terlihat.)

kennytm menjelaskan mengapa tidak aman untuk memperlakukan Streamsebagai Iterable, dan Zhong Yu menawarkan solusi yang mengizinkan penggunaan Streamsebagai Iterable, meskipun dengan cara yang tidak aman. Dimungkinkan untuk mendapatkan yang terbaik dari kedua dunia: yang dapat digunakan kembali Iterabledari Streamyang memenuhi semua jaminan yang dibuat oleh Iterablespesifikasi.

Catatan: SomeTypebukan parameter tipe di sini - Anda harus menggantinya dengan tipe yang tepat (misalnya, String) atau menggunakan refleksi

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

Ada satu kelemahan utama:

Manfaat iterasi malas akan hilang. Jika Anda berencana untuk segera beralih ke semua nilai di utas saat ini, setiap overhead akan diabaikan. Namun, jika Anda berencana untuk mengulangi hanya sebagian atau di utas yang berbeda, iterasi segera dan lengkap ini dapat memiliki konsekuensi yang tidak diinginkan.

Keuntungan besar, tentu saja, adalah Anda dapat menggunakan kembali Iterable, sedangkan (Iterable<SomeType>) stream::iteratorhanya akan mengizinkan penggunaan tunggal. Jika kode penerima akan mengulangi koleksi beberapa kali, ini tidak hanya diperlukan, tetapi kemungkinan bermanfaat untuk kinerja.

Streamtidak menerapkan Iterable. Pemahaman umum tentang Iterableapa pun yang dapat diulangi, seringkali berulang kali.Streammungkin tidak dapat diputar ulang.

Satu-satunya solusi yang dapat saya pikirkan, di mana iterable berdasarkan aliran adalah replayable juga, adalah menciptakan kembali aliran. Saya menggunakan di Supplierbawah ini untuk membuat contoh baru aliran, setiap kali iterator baru dibuat.

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

Jika Anda tidak keberatan menggunakan perpustakaan pihak ketiga cyclops-react menentukan Stream yang mengimplementasikan Stream dan Iterable dan juga dapat diputar ulang (memecahkan masalah yang dijelaskan kennytm ).

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

atau :-

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

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

[Pengungkapan Saya adalah pengembang utama cyclops-react]

Tidak sempurna, tetapi akan berhasil:

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

Tidak sempurna karena itu akan mengambil semua item dari aliran dan memasukkannya ke dalam itu List, yang bukan apa Iterabledan Streamtentang. Mereka seharusnya malas .

Anda dapat mengulangi semua file dalam folder menggunakan Stream<Path>seperti ini:

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

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

    // ...
}