Copie una transmisión para evitar que "la transmisión ya se haya operado o cerrado"

Me gustaría duplicar una secuencia de Java 8 para poder lidiar con ella dos veces. Puedo collectcomo una lista y obtener nuevas transmisiones de eso;

// doSomething() returns a stream
List<A> thing = doSomething().collect(toList());
thing.stream()... // do stuff
thing.stream()... // do other stuff

Pero creo que debería haber una forma más eficiente / elegante.

¿Existe alguna forma de copiar la secuencia sin convertirla en una colección?

De hecho, estoy trabajando con una secuencia de Eithers, así que quiero procesar la proyección izquierda de una manera antes de pasar a la proyección derecha y tratar con eso de otra manera. Algo así (que, hasta ahora, me veo obligado a usar el toListtruco).

List<Either<Pair<A, Throwable>, A>> results = doSomething().collect(toList());

Stream<Pair<A, Throwable>> failures = results.stream().flatMap(either -> either.left());
failures.forEach(failure -> ... );

Stream<A> successes = results.stream().flatMap(either -> either.right());
successes.forEach(success -> ... );

Creo que su suposición sobre la eficiencia es un poco al revés. Obtiene esta enorme recuperación de la eficiencia si solo va a usar los datos una vez, porque no tiene que almacenarlos, y los flujos le brindan potentes optimizaciones de "fusión de bucle" que le permiten hacer fluir todos los datos de manera eficiente a través de la tubería.

Si desea reutilizar los mismos datos, entonces, por definición, debe generarlos dos veces (determinísticamente) o almacenarlos. Si ya está en una colección, genial; luego, repetirlo dos veces es barato.

Experimentamos en el diseño con "flujos bifurcados". Lo que encontramos fue que apoyar esto tenía costos reales; cargó el caso común (uso una vez) a expensas del caso poco común. El gran problema era lidiar con "qué sucede cuando las dos canalizaciones no consumen datos al mismo ritmo". Ahora has vuelto a almacenar en búfer de todos modos. Esta fue una característica que claramente no tuvo su peso.

Si desea operar con los mismos datos repetidamente, almacénelos o estructura sus operaciones como Consumidores y haga lo siguiente:

stream()...stuff....forEach(e -> { consumerA(e); consumerB(e); });

También puede buscar en la biblioteca RxJava, ya que su modelo de procesamiento se presta mejor a este tipo de "bifurcación de flujo".

Puede usar una variable local con Supplierpara configurar partes comunes de la canalización de flujo.

De http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/ :

Reutilización de transmisiones

Los flujos de Java 8 no se pueden reutilizar. Tan pronto como llame a cualquier operación de terminal, la secuencia se cerrará:

Stream<String> stream = Stream.of("d2", "a2", "b1", "b3", "c")
    .filter(s -> s.startsWith("a"));
stream.anyMatch(s -> true);    // ok
stream.noneMatch(s -> true);   // exception

Calling `noneMatch` after `anyMatch` on the same stream results in the following exception:
java.lang.IllegalStateException: stream has already been operated upon or closed
at 
java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
at 
java.util.stream.ReferencePipeline.noneMatch(ReferencePipeline.java:459)
at com.winterbe.java8.Streams5.test7(Streams5.java:38)
at com.winterbe.java8.Streams5.main(Streams5.java:28)

Para superar esta limitación, tenemos que crear una nueva cadena de flujo para cada operación de terminal que queramos ejecutar, por ejemplo, podríamos crear un proveedor de flujo para construir un nuevo flujo con todas las operaciones intermedias ya configuradas:

Supplier<Stream<String>> streamSupplier =
    () -> Stream.of("d2", "a2", "b1", "b3", "c")
            .filter(s -> s.startsWith("a"));

streamSupplier.get().anyMatch(s -> true);   // ok
streamSupplier.get().noneMatch(s -> true);  // ok

Cada llamada a get() construye una nueva secuencia en la que guardamos para llamar a la operación de terminal deseada.

Utilice a Supplierpara producir la secuencia para cada operación de terminación.

Supplier<Stream<Integer>> streamSupplier = () -> list.stream();

Siempre que necesite una transmisión de esa colección, utilícela streamSupplier.get()para obtener una nueva transmisión.

Ejemplos:

1. streamSupplier.get().anyMatch(predicate);
2. streamSupplier.get().allMatch(predicate2);

Implementamos un duplicate()método para transmisiones en jOOλ , una biblioteca de código abierto que creamos para mejorar las pruebas de integración para jOOQ . Básicamente, puedes escribir:

Tuple2<Seq<A>, Seq<A>> duplicates = Seq.seq(doSomething()).duplicate();

Internamente, hay un búfer que almacena todos los valores que se han consumido de un flujo pero no del otro. Probablemente sea lo más eficiente posible si sus dos transmisiones se consumen aproximadamente al mismo ritmo y si puede vivir con la falta de seguridad de los subprocesos .

Así es como funciona el algoritmo:

static <T> Tuple2<Seq<T>, Seq<T>> duplicate(Stream<T> stream) {
    final List<T> gap = new LinkedList<>();
    final Iterator<T> it = stream.iterator();

    @SuppressWarnings("unchecked")
    final Iterator<T>[] ahead = new Iterator[] { null };

    class Duplicate implements Iterator<T> {
        @Override
        public boolean hasNext() {
            if (ahead[0] == null || ahead[0] == this)
                return it.hasNext();

            return !gap.isEmpty();
        }

        @Override
        public T next() {
            if (ahead[0] == null)
                ahead[0] = this;

            if (ahead[0] == this) {
                T value = it.next();
                gap.offer(value);
                return value;
            }

            return gap.poll();
        }
    }

    return tuple(seq(new Duplicate()), seq(new Duplicate()));
}

Más código fuente aquí

Tuple2es probablemente como su Pairtipo, mientras que Seqtiene Streamalgunas mejoras.

Puede crear una secuencia de ejecutables (por ejemplo):

results.stream()
    .flatMap(either -> Stream.<Runnable> of(
            () -> failure(either.left()),
            () -> success(either.right())))
    .forEach(Runnable::run);

Dónde failurey successson las operaciones a aplicar. Sin embargo, esto creará bastantes objetos temporales y puede que no sea más eficiente que comenzar desde una colección y transmitirla / iterarla dos veces.

Otra forma de manejar los elementos varias veces es usar Stream.peek (Consumer) :

doSomething().stream()
.peek(either -> handleFailure(either.left()))
.foreach(either -> handleSuccess(either.right()));

peek(Consumer) se puede encadenar tantas veces como sea necesario.

doSomething().stream()
.peek(element -> handleFoo(element.foo()))
.peek(element -> handleBar(element.bar()))
.peek(element -> handleBaz(element.baz()))
.foreach(element-> handleQux(element.qux()));

cyclops-react , una biblioteca a la que contribuyo, tiene un método estático que te permitirá duplicar un Stream (y devuelve un jOOλ Tuple of Streams).

    Stream<Integer> stream = Stream.of(1,2,3);
    Tuple2<Stream<Integer>,Stream<Integer>> streams =  StreamUtils.duplicate(stream);

Consulte los comentarios, existe una penalización de rendimiento en la que se incurrirá al usar un duplicado en una secuencia existente. Una alternativa más eficaz sería utilizar Streamable: -

También hay una clase Streamable (perezosa) que se puede construir a partir de Stream, Iterable o Array y reproducir varias veces.

    Streamable<Integer> streamable = Streamable.of(1,2,3);
    streamable.stream().forEach(System.out::println);
    streamable.stream().forEach(System.out::println);

AsStreamable.synchronizedFromStream (stream): se puede usar para crear un Streamable que llenará perezosamente su colección de respaldo, de tal manera que se pueda compartir entre hilos. Streamable.fromStream (stream) no incurrirá en ninguna sobrecarga de sincronización.

Para este problema en particular, también puede utilizar particiones. Algo como

     // Partition Eighters into left and right
     List<Either<Pair<A, Throwable>, A>> results = doSomething();
     Map<Boolean, Object> passingFailing = results.collect(Collectors.partitioningBy(s -> s.isLeft()));
     passingFailing.get(true) <- here will be all passing (left values)
     passingFailing.get(false) <- here will be all failing (right values)

Podemos hacer uso de Stream Builder a la hora de leer o iterar un stream. Aquí está el documento de Stream Builder .

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.Builder.html

Caso de uso

Digamos que tenemos un flujo de empleados y necesitamos usar este flujo para escribir datos de empleados en un archivo de Excel y luego actualizar la colección / tabla de empleados [Este es solo un caso de uso para mostrar el uso de Stream Builder]:

Stream.Builder<Employee> builder = Stream.builder();

employee.forEach( emp -> {
   //store employee data to excel file 
   // and use the same object to build the stream.
   builder.add(emp);
});

//Now this stream can be used to update the employee collection
Stream<Employee> newStream = builder.build();

Tuve un problema similar y pude pensar en tres estructuras intermedias diferentes a partir de las cuales crear una copia de la secuencia: a List, una matriz y a Stream.Builder. Escribí un pequeño programa de referencia, que sugería que, desde el punto de vista del desempeño, elList era aproximadamente un 30% más lento que los otros dos, que eran bastante similares.

El único inconveniente de convertir a una matriz es que es complicado si su tipo de elemento es un tipo genérico (que en mi caso lo era); por eso prefiero usar unStream.Builder .

Terminé escribiendo una pequeña función que crea un Collector:

private static <T> Collector<T, Stream.Builder<T>, Stream<T>> copyCollector()
{
    return Collector.of(Stream::builder, Stream.Builder::add, (b1, b2) -> {
        b2.build().forEach(b1);
        return b1;
    }, Stream.Builder::build);
}

Luego puedo hacer una copia de cualquier flujo strhaciendo lo str.collect(copyCollector())que se sienta bastante en consonancia con el uso idiomático de los flujos.