Converti Iterable in Stream utilizzando Java 8 JDK

Ho un'interfaccia che ritorna java.lang.Iterable<T>.

Vorrei manipolare quel risultato usando l'API Java 8 Stream.

Tuttavia Iterable non può "trasmettere".

Qualche idea su come usare l'Iterable come Stream senza convertirlo in Elenco?

C'è una risposta molto migliore rispetto all'utilizzo spliteratorUnknownSizediretto, che è sia più semplice che ottiene un risultato migliore. Iterableha un spliterator()metodo, quindi dovresti semplicemente usarlo per ottenere il tuo divisore. Nel peggiore dei casi, è lo stesso codice (utilizzato dall'implementazione predefinita spliteratorUnknownSize), ma nel caso più comune, dove la tua Iterableè già una raccolta, otterrai uno splitterator migliore e quindi migliori prestazioni dello stream (forse anche un buon parallelismo). È anche meno codice:

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

Come puoi vedere, ottenere un flusso da un Iterable(vedi anche questa domanda ) non è molto doloroso.

Se è possibile utilizzare la libreria Guava, dalla versione 21, è possibile utilizzare

Streams.stream(iterable)

Puoi facilmente creare un Streamda Iterableo Iterator:

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

Vorrei suggerire di utilizzare la libreria JOOL , nasconde la magia spliterator dietro la chiamata Seq.seq (iterabile) e fornisce anche un sacco di funzionalità utili aggiuntive.

Quindi, come menzionato in un'altra risposta, Guava ha il supporto per questo usando:

Streams.stream(iterable);

Voglio sottolineare che l'implementazione fa qualcosa di leggermente diverso rispetto alle altre risposte suggerite. Se Iterableè di tipo, Collectionlo lanciano.

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

Ho creato questa classe:

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

Penso che sia perfettamente leggibile perché non devi pensare a divisori e booleani (isParallel).

Una soluzione molto semplice per questo problema consiste nel creare Streamable<T>un'interfaccia estesa Iterable<T>che contenga un default <T> stream()metodo.

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

Ora qualcuno dei tuoi Iterable<T> è possibile rendere banalmente streaming messaggi semplicemente dichiarandoli implements Streamable<T>anziché Iterable<T>.

Se ti capita di usare Vavr (precedentemente noto come Javaslang), questo può essere facile come:

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

Un altro modo per farlo, con Java 8 e senza librerie esterne:

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