复制流，以避免“流已被操作或关闭”

我想复制一个Java 8流，以便可以处理两次。我可以collect列出并从中获得新的信息流；

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

但是我认为应该有一种更有效/更优雅的方法。

有没有一种方法可以复制流而不将其转换为集合？

我实际上正在使用Eithers 流，因此想要先处理左侧投影，然后再移至右侧投影并以另一种方式处理。有点像这样（到目前为止，我被迫使用这种toList技巧）。

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

我认为您对效率的假设有点倒退。如果您只需要使用一次数据，那么您将获得巨大的效率回报，因为您不必存储数据，而流为您提供了强大的“循环融合”优化，可以使整个数据有效地流经管道。

如果要重复使用相同的数据，那么根据定义，您要么必须生成两次（确定性地），要么将其存储。如果它已经碰巧在收藏中，那就太好了；然后迭代两次很便宜。

我们在“分叉流”中进行了设计实验。我们发现，对此进行支持需要付出实际成本；它负担了普通案例（一次使用）的负担，却以罕见案例为代价。最大的问题是处理“当两个管道不以相同的速率使用数据时会发生什么”。现在您无论如何都要返回缓冲。这个功能显然没有发挥作用。

如果要重复对相同的数据进行操作，请存储它或将其结构化为“使用者”，然后执行以下操作：

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

您可能还需要研究RxJava库，因为它的处理模型更适合于这种“流派生”。

您可以将局部变量与一起使用，Supplier以设置流管道的公共部分。

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

重用流

Java 8流无法重用。调用任何终端操作后，流就立即关闭：

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)

为了克服此限制，我们必须为要执行的每个终端操作创建一个新的流链，例如，我们可以创建一个流提供程序以构造一个已经设置了所有中间操作的新流：

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

每次调用都会get()构造一个新的流，我们可以保存该流以调用所需的终端操作。

使用a Supplier来生成每个终止操作的流。

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

每当您需要该集合的流时，请使用streamSupplier.get()来获取新的流。

例子：

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

我们已经duplicate()在jOOλ中实现了一种流方法，jOOλ是我们创建的一个开放源代码库，用于改进jOOQ的集成测试。本质上，您可以编写：

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

在内部，有一个缓冲区，用于存储从一个流而非所有流消耗的所有值。如果两个流以大约相同的速率消耗，并且如果您可以在没有线程安全的情况下生存，那么这可能与获得的效率一样。

该算法的工作原理如下：

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

更多源代码在这里

Tuple2大概是喜欢你的Pair类型，而Seq为Stream一些增强功能。

您可以创建可运行流（例如）：

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

在哪里failure和success对应用的操作。但是，这将创建许多临时对象，并且可能没有效率比从集合开始并对其进行流式处理/迭代两次的效率更高。

多次处理元素的另一种方法是使用Stream.peek（Consumer）：

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

peek(Consumer) 可以根据需要链接多次。

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

我贡献的一个库cyclops-react具有一个静态方法，该方法将允许您复制Stream（并返回jOOλStreams Tuple）。

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

查看评论，在现有Stream上使用重复项会导致性能下降。一种更高效的替代方法是使用Streamable：-

还有一个（惰性）Streamable类，可以从Stream，Iterable或Array构造该类并重播多次。

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

AsStreamable.synchronizedFromStream（stream）-可用于创建Streamable，该Streamable将以可在线程之间共享的方式延迟填充其后备集合。Streamable.fromStream（stream）将不会产生任何同步开销。

对于此特定问题，您还可以使用分区。就像是

     // 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)

在读取或迭代流时，我们可以使用Stream Builder。这是Stream Builder的文档。

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

用例

假设我们有员工流，我们需要使用此流将员工数据写入excel文件，然后更新员工集合/表[这只是用例来说明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();

我有一个类似的问题，可以想到从中创建流副本的三个不同的中间结构：a List，数组和a Stream.Builder。我写了一个基准测试程序，从性能的角度来看，List它比其他两个非常相似的程序慢了约30％。

转换为数组的唯一缺点是，如果您的元素类型是泛型类型（在我的情况下是），这将非常棘手；因此我更喜欢使用Stream.Builder。

我最终写了一个创建一个的小函数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);
}

然后，我可以str通过这样做str.collect(copyCollector())来复制任何流，这与流的惯用用法完全一致。