"Akışın zaten çalıştırıldığını veya kapatıldığını" önlemek için bir akışı kopyalayın

Bir Java 8 akışını kopyalamak istiyorum, böylece onunla iki kez ilgilenebilirim. collectListe olarak yapabilirim ve bundan yeni akışlar alabilirim;

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

Ama daha verimli / zarif bir yol olması gerektiğini düşünüyorum.

Akışı bir koleksiyona dönüştürmeden kopyalamanın bir yolu var mı?

Aslında bir Eithers akışı ile çalışıyorum , bu yüzden sol izdüşümü sağ projeksiyona geçmeden ve bununla başka bir şekilde ilgilenmeden önce bir şekilde işlemek istiyorum. Bunun gibi (ki şimdiye kadar toListhileyi kullanmak zorunda kaldım ).

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

Verimlilik hakkındaki varsayımınızın biraz ters olduğunu düşünüyorum. Verileri yalnızca bir kez kullanacaksanız, bu büyük verimlilik geri ödemesini elde edersiniz, çünkü verileri depolamak zorunda değilsiniz ve akışlar, tüm verileri ardışık düzen boyunca verimli bir şekilde aktarmanıza izin veren güçlü "döngü füzyonu" optimizasyonları sunar.

Aynı verileri yeniden kullanmak istiyorsanız, tanım gereği onu iki kez (belirleyici olarak) oluşturmanız veya depolamanız gerekir. Zaten bir koleksiyondaysa, harika; daha sonra iki kez yinelemek ucuzdur.

Tasarımda "çatallı akışlar" ile deney yaptık. Bulduğumuz şey, bunu desteklemenin gerçek maliyetleri olduğuydu; olağandışı durum pahasına ortak durumu (bir kez kullanın) yükledi. Büyük sorun, "iki ardışık düzen aynı hızda veri tüketmediğinde ne olacağı" ile ilgilenmekti. Şimdi yine de arabelleğe geri döndün. Bu, ağırlığını açıkça taşımayan bir özellikti.

Aynı veriler üzerinde tekrar tekrar çalışmak istiyorsanız, bunları saklayın veya işlemlerinizi Tüketiciler olarak yapılandırın ve aşağıdakileri yapın:

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

Ayrıca, işleme modeli bu tür "akış çatallamasına" daha iyi uyum sağladığından, RxJava kitaplığına da bakabilirsiniz.

SupplierAkış boru hattının ortak parçalarını kurmak için a ile yerel bir değişken kullanabilirsiniz .

Gönderen http://winterbe.com/posts/2014/07/31/java8-stream-tutorial-examples/ :

Akışları Yeniden Kullanma

Java 8 akışları yeniden kullanılamaz. Herhangi bir terminal işlemini aradığınız anda akış kapatılır:

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)

Bu sınırlamanın üstesinden gelmek için, yürütmek istediğimiz her terminal işlemi için yeni bir akış zinciri oluşturmalıyız, örneğin, önceden ayarlanmış tüm ara işlemlerle yeni bir akış oluşturmak için bir akış tedarikçisi oluşturabiliriz:

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

Her çağrı get(), istenen terminal işlemini çağırmak için kaydettiğimiz yeni bir akış oluşturur.

SupplierHer sonlandırma işlemi için akışı üretmek üzere a kullanın .

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

Bu koleksiyonun bir akışına ihtiyacınız olduğunda, streamSupplier.get()yeni bir akış almak için kullanın .

Örnekler:

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

Biz uyguladık duplicate()içinde akışları için yöntem jOOλ , biz entegrasyon testleri geliştirmek için oluşturulan bu açık kaynak kodlu kütüphanesinde jOOQ . Esasen şunu yazabilirsiniz:

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

Dahili olarak, bir akıştan tüketilen ancak diğerinden tüketilmeyen tüm değerleri depolayan bir arabellek vardır. İki akışınız aynı oranda tüketilirse ve iş parçacığı güvenliğinden yoksun yaşayabilirseniz, muhtemelen bu kadar etkilidir .

Algoritma şu şekilde çalışır:

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

Daha fazla kaynak kodu burada

Tuple2muhtemelen gibidir Pairoysa türü Seqolan Streambazı geliştirmeler.

Bir runnables akışı oluşturabilirsiniz (örneğin):

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

Uygulanacak işlemler nerede failureve nerede success? Ancak bu, epeyce geçici nesne yaratacaktır ve bir koleksiyondan başlayıp onu iki kez yayınlamaktan / yinelemekten daha verimli olmayabilir.

Öğeleri birden çok kez ele almanın başka bir yolu da Stream.peek (Tüketici) kullanmaktır :

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

peek(Consumer) gerektiği kadar zincirlenebilir.

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

Katkıda bulunduğum bir kütüphane olan cyclops-react , bir Akışı kopyalamanıza izin verecek (ve bir jOOλ Akım Tuple'ı döndüren) statik bir metoda sahip.

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

Yorumlara bakın, mevcut bir Akışta kopyayı kullanırken ortaya çıkacak performans cezası vardır. Daha performanslı bir alternatif, Streamable'ı kullanmak olabilir: -

Ayrıca, bir Akış, Yinelenebilir veya Diziden oluşturulabilen ve birden çok kez yeniden oynatılabilen (tembel) bir Yayınlanabilir sınıf da vardır.

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

AsStreamable.synchronizedFromStream (stream) - iş parçacıkları arasında paylaşılabilecek bir şekilde yedekleme koleksiyonunu tembel bir şekilde dolduracak bir Streamable oluşturmak için kullanılabilir. Streamable.fromStream (stream) herhangi bir senkronizasyon ek yüküne neden olmaz.

Bu özel sorun için bölümlemeyi de kullanabilirsiniz. Gibi bir şey

     // 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'ı bir akışı okurken veya yinelerken kullanabiliriz. İşte Stream Builder'ın belgesi .

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

Kullanım alanı

Diyelim ki çalışan akışımız var ve çalışan verilerini excel dosyasına yazmak için bu akışı kullanmamız ve ardından çalışan koleksiyonunu / tablosunu güncellememiz gerekiyor [Bu sadece Stream Builder'ın kullanımını göstermek için kullanım örneğidir]:

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

Benzer bir problemim vardı ve akışın bir kopyasını oluşturmak için üç farklı ara yapı düşünebilirdim: a List, bir dizi ve a Stream.Builder. Küçük bir kıyaslama programı yazdım ve performans açısından bakıldığındaList oldukça benzer olan diğer ikisinden yaklaşık% 30 daha yavaş olduğunu .

Bir diziye dönüştürmenin tek dezavantajı, öğe türünüzün genel bir tür olması (benim durumumda öyleydi); bu yüzden kullanmayı tercih ediyorumStream.Builder .

Sonunda aşağıdakileri oluşturan küçük bir işlev yazdım 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);
}

Sonra herhangi akışı bir kopyasını yapabilirsiniz stryaparak str.collect(copyCollector())oldukça akışların deyimsel kullanımında doğrultusunda hissediyor.