Tại sao Stream <T> không triển khai lặp lại <T>?

Trong Java 8, chúng ta có lớp Stream <T> , có một phương thức tò mò

Iterator<T> iterator()

Vì vậy, bạn sẽ mong đợi nó triển khai giao diện Iterable <T> , yêu cầu chính xác phương pháp này, nhưng thực tế không phải vậy.

Khi tôi muốn lặp lại một luồng bằng vòng lặp foreach, tôi phải làm một cái gì đó như

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

Am i thiếu cái gì ở đây?

Mọi người đã hỏi tương tự trong danh sách gửi thư . Lý do chính là Iterable cũng có một ngữ nghĩa lặp lại, trong khi Stream thì không.

Tôi nghĩ lý do chính là Iterablengụ ý tái sử dụng, trong khi đó Streamlà thứ chỉ có thể được sử dụng một lần - giống như một Iterator.

Nếu được Streammở rộng Iterablethì mã hiện tại có thể gây ngạc nhiên khi nó nhận được một lần Iterableném Exceptionthứ hai for (element : iterable).

Để chuyển đổi Streamthành một Iterable, bạn có thể làm

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

Để vượt qua một Streamphương pháp mong đợi Iterable,

void foo(Iterable<X> iterable)

đơn giản

foo(stream::iterator) 

tuy nhiên nó có vẻ buồn cười; có thể tốt hơn để rõ ràng hơn một chút

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

Tôi muốn chỉ ra rằng StreamExviệc thực hiện Iterable(và Stream), cũng như một loạt các chức năng vô cùng tuyệt vời khác bị thiếu Stream.

Bạn có thể sử dụng Luồng trong một forvòng lặp như sau:

Stream<T> stream = ...;

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

(Chạy đoạn trích này tại đây )

(Cái này sử dụng giao diện chức năng Java 8.)

(Điều này được đề cập trong một số ý kiến ​​ở trên (ví dụ: Alexanderr Dubinsky ), nhưng tôi muốn rút nó ra thành một câu trả lời để làm cho nó rõ hơn.)

kennytm đã mô tả lý do tại sao không an toàn khi coi Streamnhư một Iterable, và Zhong Yu đưa ra một cách giải quyết cho phép sử dụng Streamnhư trong Iterable, mặc dù theo cách không an toàn. Có thể có được điều tốt nhất của cả hai thế giới: có thể tái sử dụng Iterabletừ một Streamthế giới đáp ứng tất cả các đảm bảo được thực hiện bởi Iterablethông số kỹ thuật.

Lưu ý: SomeTypekhông phải là một tham số loại ở đây - bạn cần thay thế nó bằng một loại thích hợp (ví dụ String:) hoặc dùng đến sự phản chiếu

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

Có một nhược điểm lớn:

Những lợi ích của việc lặp lại lười biếng sẽ bị mất. Nếu bạn dự định lặp lại ngay lập tức tất cả các giá trị trong luồng hiện tại, mọi chi phí sẽ không đáng kể. Tuy nhiên, nếu bạn dự định chỉ lặp lại một phần hoặc trong một luồng khác, việc lặp lại ngay lập tức và hoàn chỉnh này có thể có những hậu quả không lường trước được.

Tất nhiên, lợi thế lớn là bạn có thể sử dụng lại Iterable, trong khi (Iterable<SomeType>) stream::iteratorchỉ cho phép sử dụng một lần. Nếu mã nhận sẽ lặp đi lặp lại trên bộ sưu tập nhiều lần, điều này không chỉ cần thiết mà còn có lợi cho hiệu suất.

Streamkhông thực hiện Iterable. Sự hiểu biết chung về Iterablebất cứ điều gì có thể được lặp đi lặp lại, thường xuyên lặp đi lặp lại. Streamcó thể không được phát lại.

Cách giải quyết duy nhất mà tôi có thể nghĩ đến, trong đó một lần lặp dựa trên luồng cũng có thể phát lại được, là tạo lại luồng. Tôi đang sử dụng một Supplierbên dưới để tạo một phiên bản mới của luồng, mỗi khi một trình lặp mới được tạo.

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

Nếu bạn không phiền khi sử dụng thư viện của bên thứ ba, cyclops-Reac sẽ xác định Luồng thực hiện cả Luồng và Iterable và cũng có thể phát lại được (giải quyết vấn đề kennytm được mô tả ).

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

hoặc là :-

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

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

[Tiết lộ Tôi là nhà phát triển chính của cyclops-Reac]

Không hoàn hảo, nhưng sẽ hoạt động:

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

Không hoàn hảo bởi vì nó sẽ tìm nạp tất cả các mục từ luồng và đặt chúng vào đó List, đó không phải là chính xác những gì Iterablevà Streamvề. Họ được cho là lười biếng .

Bạn có thể lặp lại tất cả các tệp trong một thư mục bằng cách sử dụng Stream<Path>như sau:

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

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

    // ...
}