Pourquoi Stream <T> n'implémente-t-il pas Iterable <T>?

En Java 8, nous avons la classe Stream <T> , qui a curieusement une méthode

Iterator<T> iterator()

Vous vous attendez donc à ce qu'il implémente l'interface Iterable <T> , qui nécessite exactement cette méthode, mais ce n'est pas le cas.

Quand je veux parcourir un Stream en utilisant une boucle foreach, je dois faire quelque chose comme

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)) { ... }

Est-ce que j'ai râté quelque chose?

Les gens ont déjà demandé la même chose sur la liste de diffusion ☺. La principale raison est qu'Iterable a également une sémantique réitérable, contrairement à Stream.

Je pense que la raison principale est que cela Iterableimplique la réutilisabilité, alors que Streamc'est quelque chose qui ne peut être utilisé qu'une seule fois - plus comme un Iterator.

S'il est Streamétendu, le Iterablecode existant pourrait être surpris lorsqu'il reçoit un Iterablequi lance une Exceptiondeuxième fois for (element : iterable).

Pour convertir un Streamen un Iterable, vous pouvez faire

Stream<X> stream = null;
Iterable<X> iterable = stream::iterator

Pour passer un Streamà une méthode qui attend Iterable,

void foo(Iterable<X> iterable)

simplement

foo(stream::iterator) 

mais cela a probablement l'air drôle; il vaudrait peut-être mieux être un peu plus explicite

foo( (Iterable<X>)stream::iterator );

Je tiens à souligner que StreamExcela met en œuvre Iterable(et Stream), ainsi qu'une foule d'autres fonctionnalités extrêmement impressionnantes manquantes Stream.

Vous pouvez utiliser un Stream dans une forboucle comme suit:

Stream<T> stream = ...;

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

(Exécutez cet extrait ici )

(Cela utilise une distribution d'interface fonctionnelle Java 8.)

(Ceci est couvert dans certains des commentaires ci-dessus (par exemple Aleksandr Dubinsky ), mais je voulais le retirer dans une réponse pour le rendre plus visible.)

kennytm a expliqué pourquoi il n'est pas sûr de traiter un Streamcomme un Iterable, et Zhong Yu a proposé une solution de contournement qui permet d'utiliser un Streamcomme dans Iterable, bien que de manière dangereuse. Il est possible d'obtenir le meilleur des deux mondes: un réutilisable à Iterablepartir d'un Streamqui répond à toutes les garanties apportées par le Iterablecahier des charges.

Remarque: SomeTypen'est pas un paramètre de type ici - vous devez le remplacer par un type approprié (par exemple, String) ou recourir à la réflexion

Stream<SomeType> stream = ...;
Iterable<SomeType> iterable = stream.collect(toList()):

Il y a un inconvénient majeur:

Les avantages de l'itération paresseuse seront perdus. Si vous envisagez d'itérer immédiatement toutes les valeurs du thread actuel, les frais généraux seront négligeables. Cependant, si vous prévoyez d'itérer seulement partiellement ou dans un thread différent, cette itération immédiate et complète pourrait avoir des conséquences inattendues.

Le grand avantage, bien sûr, est que vous pouvez réutiliser le Iterable, alors (Iterable<SomeType>) stream::iteratorqu'il ne permettrait qu'une seule utilisation. Si le code de réception itère plusieurs fois sur la collection, cela est non seulement nécessaire, mais probablement bénéfique pour les performances.

Streamne met pas en œuvre Iterable. La compréhension générale de Iterabletout ce qui peut être répété, souvent encore et encore. Streampeut ne pas être rejouable.

La seule solution de contournement à laquelle je peux penser, où un itérable basé sur un flux est également rejouable, est de recréer le flux. J'utilise un Supplierci - dessous pour créer une nouvelle instance de flux, chaque fois qu'un nouvel itérateur est créé.

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

Si cela ne vous dérange pas d'utiliser des bibliothèques tierces, cyclops-react définit un Stream qui implémente à la fois Stream et Iterable et est également rejouable (résolution du problème décrit par Kennedy ).

 Stream<String> stream = ReactiveSeq.of("hello","world")
                                    .map(s->"prefix-"+s);

ou :-

 Iterable<String> stream = ReactiveSeq.of("hello","world")
                                      .map(s->"prefix-"+s);

 stream.forEach(System.out::println);
 stream.forEach(System.out::println);

[Divulgation Je suis le développeur principal de cyclops-react]

Pas parfait, mais fonctionnera:

iterable = stream.collect(Collectors.toList());

Pas parfait car il récupérera tous les éléments du flux et les placera dans ce Listqui n'est pas exactement de quoi Iterableil Streams'agit. Ils sont censés être paresseux .

Vous pouvez parcourir tous les fichiers d'un dossier en utilisant Stream<Path>comme ceci:

Path path = Paths.get("...");
Stream<Path> files = Files.list(path);

for (Iterator<Path> it = files.iterator(); it.hasNext(); )
{
    Object file = it.next();

    // ...
}