Чому Stream <T> не реалізує Iterable <T>?

У Java 8 у нас є клас Stream <T> , у якому цікаво є метод

Iterator<T> iterator()

Тож ви б очікували, що він реалізує інтерфейс Iterable <T> , який вимагає саме цього методу, але це не так.

Коли я хочу повторити потік за допомогою циклу foreach, я повинен зробити щось на кшталт

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

Я щось тут пропускаю?

Люди вже запитували те саме в списку розсилки ☺. Основна причина - Iterable також має повторювану семантику, а Stream - ні.

Я думаю, що головна причина полягає в тому, що Iterableпередбачається повторне використання, тоді як Streamце те, що можна використовувати лише один раз - більше схоже на Iterator.

Якщо Streamрозширено, Iterableто існуючий код може бути здивований, коли він отримає Iterableте, що кидає Exceptionвдруге for (element : iterable).

Щоб перетворити a Streamв an Iterable, ви можете зробити

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

Щоб перейти Streamдо очікуваного методу Iterable,

void foo(Iterable<X> iterable)

просто

foo(stream::iterator) 

проте це, мабуть, виглядає смішно; може бути краще бути явнішим

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

Я хотів би зазначити, що StreamExреалізація Iterable(і Stream), а також безліч інших надзвичайно дивовижних функціональних можливостей відсутні Stream.

Ви можете використовувати Потік у forциклі таким чином:

Stream<T> stream = ...;

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

(Запустіть цей фрагмент тут )

(Для цього використовується функціональний інтерфейс Java 8.)

(Це висвітлено в деяких коментарях вище (наприклад, Олександр Дубінський ), але я хотів витягнути це у відповідь, щоб зробити його більш помітним.)

kennytm описав , чому це небезпечно лікувати Streamяк Iterableі Чжун Юй запропонував обхідний шлях , який дозволяє з допомогою , Streamяк і в Iterable, хоча і небезпечне. Можна отримати найкраще з обох світів: багаторазове використання Iterableіз такого, Streamяке відповідає всім гарантіям, що даються Iterableспецифікацією.

Примітка: SomeTypeтут не параметр типу - вам потрібно замінити його на належний тип (наприклад, String) або вдатися до роздумів

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

Є один головний недолік:

Переваги лінивої ітерації будуть втрачені. Якщо ви планували негайно повторити всі значення в поточному потоці, будь-які накладні витрати будуть незначними. Однак якщо ви планували повторити лише частково або іншою темою, ця негайна та повна ітерація може мати непередбачувані наслідки.

Великою перевагою, звичайно, є те, що ви можете повторно використовувати Iterable, тоді як (Iterable<SomeType>) stream::iteratorдозволите лише одне використання. Якщо отримуючий код буде повторюватися над колекцією кілька разів, це не тільки необхідно, але ймовірно сприятливо для продуктивності.

Streamне реалізує Iterable. Загальне розуміння поняття Iterable- це все, що можна повторити, часто знову і знову.Streamможе не підлягати відтворенню.

Єдине вирішення, яке я можу придумати, коли повторюваний потік, заснований на потоці, також є повторним створенням потоку. Я використовую Supplierнижче для створення нового екземпляра потоку кожного разу, коли створюється новий ітератор.

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

Якщо ви не заперечуєте проти використання сторонніх бібліотек, cyclops- react визначає Потік, який реалізує як Stream, так і Iterable і також підлягає відновленню (вирішення описаної проблеми kennytm ).

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

або: -

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

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

[Розкриття інформації Я є провідним розробником циклоп-реакції]

Не ідеально, але буде працювати:

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

Не ідеально, тому що він витягне всі елементи з потоку і помістить їх у те List, що не є саме тим Iterableі Streamпро що йдеться . Вони, мабуть, ліниві .

Ви можете повторити всі файли в папці, використовуючи Stream<Path>такий:

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

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

    // ...
}