Comment implémenter un flux Java?

Je veux mettre en œuvre un Stream<T>.

Je ne veux pas simplement utiliser implements Stream<T>parce que j'aurais à mettre en œuvre une tonne de méthodes.

Cela peut-il être évité?

Être plus concret, comment puis-je diffuser t1t2 et t3 par exemple:

class Foo<T> {
    T t1, t2, t3;

    Foo(T t1, T t2, T t3) {
        this.t1 = t1;
        this.t2 = t2;
        this.t3 = t3;
    }
}

source d'informationauteur clankill3r

  1. 26

    Le JDK standard de mise en œuvre de Stream est la classe interne java.util.stream.ReferencePipelinevous ne peut pas instancier directement.

    Au lieu de cela, vous pouvez utiliser java.util.stream.Stream.builder()java.util.stream.StreamSupport.stream(Spliterator<T>, boolean) et diversUnDeux d'autres statique usine méthodes pour créer une instance de l'implémentation par défaut.

    À l'aide d'un spliterator est probablement le plus puissant approche car elle permet de fournir des objets langoureusement tout en permettant la parallélisation efficace si votre source peut être divisé en plusieurs morceaux.

    En outre vous pouvez également convertir des flux dans spliterators, les envelopper dans une coutume spliterator puis de les convertir en arrière dans un cours d'eau si vous avez besoin de mettre en place votre propre stateful les opérations intermédiaires - par exemple en raison de lacunes dans la norme Api - depuis plus disponibles intermédiaire ops ne sont pas autorisés à être dynamique.
    Voir cette SORTE de réponse pour un exemple.

    En principe, vous pouvez écrire votre propre implémentation de l'interface de flux, mais qui serait assez fastidieux.

  2. 9

    Vous n'avez généralement pas besoin d'écrire votre propre classe de flux. Au lieu de cela, vous pouvez créer des flux par les méthodes existantes. Par exemple, voici comment créer un flux de données de la valeur 1, 100:

      AtomicInteger n = new AtomicInteger(0);
  Stream<Integer> stream = Stream.generate(() -> n.incrementAndGet()).limit(100);

    donc, ici, nous avons créé un courant infini des nombres entiers: 1, 2, 3, .... puis nous avons utilisé limit(100) sur l'infini de flux pour obtenir un flux de 100 éléments.

    Pour plus de clarté, si vous voulez un flux de nombres entiers (à intervalles réguliers), vous devez utiliser IntStream.range(). C'est juste un exemple pour montrer comment les flux de données peuvent être définis à l'aide de Stream.generate() qui vous donne plus de souplesse, car elle permet l'utilisation arbitraire de la logique pour la détermination de la vapeur éléments.

  3. 8

    Si vous êtes désireux de faire votre propre Flux parce que vous voulez personnalisé close() logique, la solution la plus simple est de créer un Flux à partir d'un Itérateur, et d'appeler onClose(Runnable). Par exemple, pour diffusion à partir d'un Lecteur via l'Jackson:

    MappingIterator<?> values = objectMapper.reader(type).readValues(reader);
return StreamSupport
        .stream(Spliterators.spliteratorUnknownSize(values, Spliterator.ORDERED), false)
        .onClose(() -> {
            try {
                reader.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
  4. 4

    D'autres ont répondu de la façon de fournir une usage général Stream mise en œuvre. Concernant votre spécifiques exigence, il suffit de faire ceci:

    class Foo<T> {

    T t1, t2, t3;

    Foo(T t1, T t2, T t3) {
        this.t1 = t1;
        this.t2 = t2;
        this.t3 = t3;
    }

    Stream<T> stream() {
        return Stream.of(t1, t2, t3);
    }
}
  5. 3

    Par souci d'exhaustivité, que je n'ai pas trouvé ce directement parmi les réponses ici DONC:
    Si vous souhaitez transformer un système d'Itérateur dans un cours d'eau (par exemple, parce que vous voulez générer des éléments successivement), utilisez ceci: 

    StreamSupport.stream(
    Spliterators.spliterator(myIterator, /* initial size*/ 0L, Spliterator.NONNULL), 
    /* not parallel */ false);

    J'ai trouvé cela un peu difficile à trouver, vous avez besoin de savoir StreamSupport, Spliterators et Spliterator