Konwersja Iterable do Stream przy użyciu Java 8 JDK

Jeśli możesz używać biblioteki Guava, od wersji 21, możesz użyć

Streams.stream(iterable)

Możesz łatwo utworzyć Stream z Iterable lub Iterator:

public static <T> Stream<T> stream(Iterable<T> iterable) {
    return StreamSupport.stream(
        Spliterators.spliteratorUnknownSize(
            iterable.iterator(),
            Spliterator.ORDERED
        ),
        false
    );
}

Chciałbym zasugerować Użycie biblioteki JOOL , która ukrywa magię spliteratora za wywołaniem Seq.seq(iterable), a także zapewnia całą masę dodatkowych przydatnych funkcjonalności.

Tak jak inna odpowiedź wspomniana Guava ma wsparcie dla tego za pomocą:

Streams.stream(iterable);

Chcę podkreślić, że implementacja robi coś nieco innego niż inne sugerowane odpowiedzi. Jeśli {[2] } jest typu Collection, rzucają go.

public static <T> Stream<T> stream(Iterable<T> iterable) {
  return (iterable instanceof Collection)
    ? ((Collection<T>) iterable).stream()
    : StreamSupport.stream(iterable.spliterator(), false);
}

public static <T> Stream<T> stream(Iterator<T> iterator) {
  return StreamSupport.stream(
    Spliterators.spliteratorUnknownSize(iterator, 0),
    false
  );
}

I ' ve created this class:

public class Streams {
    /**
     * Converts Iterable to stream
     */
    public static <T> Stream<T>  streamOf(final Iterable<T> iterable) {
        return toStream(iterable, false);
    }

    /**
     * Converts Iterable to parallel stream
     */
    public static <T> Stream<T> parallelStreamOf(final Iterable<T> iterable) {
        return toStream(iterable, true);
    }

    private static <T> Stream<T> toStream(final Iterable<T> iterable, final boolean isParallel) {
        return StreamSupport.stream(iterable.spliterator(), isParallel);
    }
}

Myślę, że jest doskonale czytelny, ponieważ nie musisz myśleć o spliteratorach i booleanach (isParallel).

Bardzo prostym obejściem tego problemu jest utworzenie Streamable<T> interfejsu rozszerzającego Iterable<T>, który zawiera metodę default <T> stream().

interface Streamable<T> extends Iterable<T> {
    default Stream<T> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}

Teraz każdy z twoich Iterable<T>s może być trywialnie streamowalny tylko przez zadeklarowanie ich implements Streamable<T> zamiast Iterable<T>.

Jeśli zdarzy ci się użyć Vavr (wcześniej znanego jako Javaslang), może to być tak proste, jak:

Iterable i = //...
Stream.ofAll(i);

Inny sposób, aby to zrobić, z Java 8 i bez zewnętrznych bibliotek:

Stream.concat(collectionA.stream(), collectionB.stream())
      .collect(Collectors.toList())