Convertir Iterable en Stream à l'aide de Java 8 JDK

J'ai une interface qui revient java.lang.Iterable<T>.

Je voudrais manipuler ce résultat en utilisant l'API Java 8 Stream.

Cependant, Iterable ne peut pas "diffuser".

Avez-vous une idée de comment utiliser l'itérable en tant que flux sans le convertir en liste?

Il y a une bien meilleure réponse que d'utiliser spliteratorUnknownSizedirectement, ce qui est à la fois plus facile et obtient un meilleur résultat. Iterablea une spliterator()méthode, vous devez donc simplement l'utiliser pour obtenir votre séparateur. Dans le pire des cas, c'est le même code (que l'implémentation par défaut utilise spliteratorUnknownSize), mais dans le cas le plus courant, où votre Iterableest déjà une collection, vous obtiendrez un meilleur séparateur, et donc de meilleures performances de flux (peut-être même un bon parallélisme). C'est aussi moins de code:

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

Comme vous pouvez le voir, obtenir un flux depuis un Iterable(voir aussi cette question ) n'est pas très douloureux.

Si vous pouvez utiliser la bibliothèque Guava, depuis la version 21, vous pouvez utiliser

Streams.stream(iterable)

Vous pouvez facilement créer un à Streampartir d'un Iterableou Iterator:

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

Je voudrais suggérer d'utiliser la bibliothèque JOOL , elle cache la magie du séparateur derrière l'appel Seq.seq (itérable) et fournit également tout un tas de fonctionnalités utiles supplémentaires.

Donc, comme une autre réponse mentionnée, Guava prend en charge cela en utilisant:

Streams.stream(iterable);

Je tiens à souligner que la mise en œuvre fait quelque chose de légèrement différent des autres réponses suggérées. Si le Iterableest de type, Collectionil le lance.

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

J'ai créé cette 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);
    }
}

Je pense que c'est parfaitement lisible car vous n'avez pas à penser aux séparateurs et aux booléens (isParallel).

Une solution de contournement très simple pour ce problème consiste à créer une Streamable<T>extension d'interface contenant Iterable<T>une default <T> stream()méthode.

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

Désormais, n'importe lequel de vos Iterable<T>fichiers peut être simplifié en streaming simplement en les déclarant à la implements Streamable<T>place de Iterable<T>.

Si vous utilisez Vavr (anciennement Javaslang), cela peut être aussi simple que:

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

Une autre façon de le faire, avec Java 8 et sans bibliothèques externes:

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