Konwertuj Iterable na Stream za pomocą Java 8 JDK

Mam interfejs, który zwraca java.lang.Iterable<T>.

Chciałbym manipulować tym wynikiem przy użyciu interfejsu API Java 8 Stream.

Jednak Iterable nie może „przesyłać strumieniowo”.

Masz pomysł, jak używać Iterable jako strumienia bez konwertowania go na List?

Odpowiedź jest znacznie lepsza niż spliteratorUnknownSizebezpośrednie, co jest łatwiejsze i daje lepszy wynik. Iterablema spliterator()metodę, więc powinieneś jej użyć, aby uzyskać swój spliterator. W najgorszym przypadku jest to ten sam kod (używana jest implementacja domyślna spliteratorUnknownSize), ale w bardziej powszechnym przypadku, gdy Twoja Iterablekolekcja jest już zbiorem, otrzymasz lepszy spliterator, a zatem lepszą wydajność strumienia (może nawet dobrą równoległość). To także mniej kodu:

StreamSupport.stream(iterable.spliterator(), false)
             .filter(...)
             .moreStreamOps(...);

Jak widać, uzyskanie strumienia z Iterable(patrz także to pytanie ) nie jest bardzo bolesne.

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

Streams.stream(iterable)

Można łatwo utworzyć StreamOut Of Iterablelub 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 funkcji.

Tak więc, jak wspomniano w innej odpowiedzi, Guava wspiera to za pomocą:

Streams.stream(iterable);

Chcę podkreślić, że implementacja robi coś nieco innego niż inne sugerowane odpowiedzi. Jeśli Iterablejest 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
  );
}

Stworzyłem tę klasę:

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 to doskonale czytelne, ponieważ nie musisz myśleć o spliteratorach i booleanach (isParallel).

Bardzo prostym obejściem tego problemu jest utworzenie Streamable<T>rozszerzenia interfejsu Iterable<T>zawierającego default <T> stream()metodę.

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

Teraz każdy z twoich Iterable<T>może być w prosty sposób udostępniony do streamingu, po prostu zadeklarując je implements Streamable<T>zamiast Iterable<T>.

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

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

Innym sposobem na to, z Java 8 i bez zewnętrznych bibliotek:

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