ストリームをコピーして、「ストリームはすでに操作されているか、閉じられています」

2回処理できるように、Java 8ストリームを複製したいと思います。私ができるcollectことから、新たなストリームを取得し、リストのように。

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

しかし、もっと効率的でエレガントな方法があるべきだと思います。

コレクションに変換せずにストリームをコピーする方法はありますか？

私は実際にはEithersのストリームで作業しているので、右のプロジェクションに移動して別の方法で処理する前に、左のプロジェクションを1つの方法で処理したいとします。このようなもの（これまでのところ、私は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 -> ... );

効率性についてのあなたの仮定は、ちょっと後ろ向きだと思います。データを1度だけ使用する場合は、データを保存する必要がないため、この大きな効率の見返りが得られます。また、ストリームにより、強力な「ループフュージョン」最適化により、データ全体をパイプラインに効率的に流すことができます。

同じデータを再利用する場合は、定義上、データを2回（確定的に）生成するか、保存する必要があります。コレクションに既に含まれている場合は、すばらしいです。その後、2回繰り返すのは安価です。

「フォークストリーム」を使用してデザインを実験しました。私たちが見つけたのは、これをサポートすることには実際のコストがかかるということです。まれなケースを犠牲にして、よくあるケースに負担をかけました（1回使用）。大きな問題は、「2つのパイプラインが同じ速度でデータを消費しないとどうなるか」を処理することでした。これで、とにかくバッファリングに戻りました。これは明らかにその重さを担っていない機能でした。

同じデータを繰り返し操作する場合は、データを保存するか、コンシューマーとして操作を構造化して、次の操作を行います。

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

RxJavaライブラリーを調べることもできます。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);

jOOQの統合テストを改善するために作成したオープンソースライブラリduplicate()であるjOOλにストリームのメソッドを実装しました。基本的に、あなたはただ書くことができます：

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

内部的には、1つのストリームからは消費されたが、他のストリームからは消費されなかったすべての値を格納するバッファーがあります。これは、2つのストリームがほぼ同じ速度で消費され、スレッドセーフの欠如に耐えることができる場合と同じくらい効率的です。

アルゴリズムの仕組みは次のとおりです。

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。ただし、これによりかなりの数の一時オブジェクトが作成され、コレクションから開始して、それを2回ストリーミング/反復するよりも効率的でない場合があります。

要素を複数回処理する別の方法は、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には、ストリームを複製できる（そしてストリームのjOOλタプルを返す）静的メソッドがあります。

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

コメントを参照してください。既存のストリームで複製を使用すると、パフォーマンスが低下します。より高性能な代替手段は、Streamableを使用することです：-

また、Stream、Iterable、またはArrayから構築して複数回再生できる（遅延）Streamableクラスもあります。

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

同様の問題があり、ストリームのコピーを作成するための3つの異なる中間構造、a List、配列、およびを考えることができましたStream.Builder。私は小さなベンチマークプログラムを作成しました。これは、パフォーマンスの観点から、Listかなり似ている他の2つよりも約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())と感じることにより、任意のストリームのコピーを作成できます。