Почему 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).

Чтобы преобразовать Streamв 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.

Вы можете использовать Stream в forцикле следующим образом:

Stream<T> stream = ...;

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

(Запустите этот фрагмент здесь )

(При этом используется функциональный интерфейс Java 8).

(Это описано в некоторых комментариях выше (например, Александр Дубинский ), но я хотел вытащить его в ответ, чтобы сделать его более заметным.)

Кеннитм описал, почему небезопасно относиться к a Streamкак к Iterable, и Чжун Ю предложил обходной путь, который позволяет использовать a Streamin in 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);
    }

Если вы не возражаете против использования сторонних библиотек, циклоп-реакция определяет поток, который реализует оба потока и итерируемый, а также воспроизводимый (решение проблемы описанной 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();

    // ...
}