Sao chép luồng để tránh "luồng đã được vận hành hoặc đã đóng"

Tôi muốn sao chép một luồng Java 8 để tôi có thể xử lý nó hai lần. Tôi có thể collectlàm danh sách và nhận các luồng mới từ đó;

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

Nhưng tôi nghĩ rằng nên có một cách hiệu quả / thanh lịch hơn.

Có cách nào để sao chép luồng mà không chuyển luồng đó thành một bộ sưu tập không?

Tôi thực sự đang làm việc với một luồng Eithers, vì vậy muốn xử lý hình chiếu bên trái theo một cách trước khi chuyển sang hình chiếu bên phải và xử lý theo cách khác. Kiểu như thế này (mà cho đến nay, tôi buộc phải sử dụng toListthủ thuật với).

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

Tôi nghĩ rằng giả định của bạn về hiệu quả là loại ngược lại. Bạn sẽ nhận được khoản hoàn vốn hiệu quả khổng lồ này nếu bạn chỉ sử dụng dữ liệu một lần, vì bạn không phải lưu trữ dữ liệu và các luồng cung cấp cho bạn các tính năng tối ưu hóa "kết hợp vòng lặp" mạnh mẽ cho phép bạn chuyển toàn bộ dữ liệu một cách hiệu quả qua đường ống.

Nếu bạn muốn sử dụng lại cùng một dữ liệu, thì theo định nghĩa, bạn phải tạo nó hai lần (một cách xác định) hoặc lưu trữ nó. Nếu nó đã có trong một bộ sưu tập, thật tuyệt; sau đó lặp lại nó hai lần là rẻ.

Chúng tôi đã thử nghiệm trong thiết kế với "luồng phân nhánh". Những gì chúng tôi nhận thấy là hỗ trợ điều này có chi phí thực sự; nó tạo gánh nặng cho trường hợp phổ biến (sử dụng một lần) với chi phí của trường hợp không phổ biến. Vấn đề lớn là giải quyết "điều gì sẽ xảy ra khi hai đường ống không tiêu thụ dữ liệu ở cùng một tốc độ." Bây giờ bạn vẫn quay lại bộ đệm. Đây là một tính năng rõ ràng không có trọng lượng của nó.

Nếu bạn muốn thao tác lặp lại trên cùng một dữ liệu, hãy lưu trữ dữ liệu đó hoặc cấu trúc hoạt động của bạn với tư cách Người tiêu dùng và thực hiện như sau:

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

Bạn cũng có thể xem xét thư viện RxJava, vì mô hình xử lý của nó cho phép bản thân nó tốt hơn đối với loại "stream forking".

Bạn có thể sử dụng một biến cục bộ với một Supplierđể thiết lập các phần chung của đường dẫn luồng.

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

Sử dụng lại các luồng

Java 8 luồng không thể được sử dụng lại. Ngay sau khi bạn gọi bất kỳ thao tác đầu cuối nào, luồng sẽ bị đóng:

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)

Để khắc phục hạn chế này, chúng ta phải tạo một chuỗi luồng mới cho mọi thao tác đầu cuối mà chúng ta muốn thực hiện, ví dụ: chúng ta có thể tạo một nhà cung cấp luồng để xây dựng một luồng mới với tất cả các thao tác trung gian đã được thiết lập:

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

Mỗi cuộc gọi để get()xây dựng một luồng mới mà chúng ta sẽ lưu để gọi hoạt động đầu cuối mong muốn.

Sử dụng a Supplierđể tạo luồng cho mỗi hoạt động kết thúc.

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

Bất cứ khi nào bạn cần một luồng của bộ sưu tập đó, hãy sử dụng streamSupplier.get()để nhận một luồng mới.

Ví dụ:

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

Chúng tôi đã triển khai một duplicate()phương pháp cho các luồng trong jOOλ , một thư viện Nguồn mở mà chúng tôi đã tạo để cải thiện kiểm tra tích hợp cho jOOQ . Về cơ bản, bạn chỉ có thể viết:

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

Bên trong, có một bộ đệm lưu trữ tất cả các giá trị đã được sử dụng từ một luồng nhưng không từ luồng khác. Điều đó có thể hiệu quả như nó đạt được nếu hai luồng của bạn được sử dụng ở cùng một tốc độ và nếu bạn có thể sống với việc thiếu an toàn luồng .

Đây là cách thuật toán hoạt động:

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

Thêm mã nguồn tại đây

Tuple2có lẽ như bạn Pairchủng loại, trong khi đó Seqlà Streamvới một số cải tiến.

Bạn có thể tạo một dòng các khả năng chạy (ví dụ):

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

Các thao tác cần áp dụng ở đâu failurevà ở đâu success. Tuy nhiên, điều này sẽ tạo ra một số đối tượng tạm thời và có thể không hiệu quả hơn việc bắt đầu từ một bộ sưu tập và phát trực tuyến / lặp lại nó hai lần.

Một cách khác để xử lý các phần tử nhiều lần là sử dụng Stream.peek (Người tiêu dùng) :

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

peek(Consumer) có thể được xâu chuỗi nhiều lần nếu cần.

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

cyclops-react , một thư viện mà tôi đóng góp, có một phương thức tĩnh cho phép bạn sao chép một Luồng (và trả về một jOOλ Tuple of Streams).

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

Xem nhận xét, sẽ có hình phạt về hiệu suất sẽ phát sinh khi sử dụng bản sao trên Luồng hiện có. Một giải pháp thay thế hiệu quả hơn sẽ là sử dụng Streamable: -

Ngoài ra còn có một lớp Streamable (lười biếng) có thể được xây dựng từ Stream, Iterable hoặc Array và được phát lại nhiều lần.

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

AsStreamable.synchronizedFromStream (luồng) - có thể được sử dụng để tạo một Streamable sẽ đưa vào bộ sưu tập sao lưu của nó một cách lười biếng, theo cách có thể được chia sẻ trên các luồng. Streamable.fromStream (luồng) sẽ không phải chịu bất kỳ chi phí đồng bộ hóa nào.

Đối với vấn đề cụ thể này, bạn cũng có thể sử dụng phân vùng. Cái gì đó như

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

Chúng tôi có thể sử dụng Trình tạo luồng tại thời điểm đọc hoặc lặp lại luồng. Đây là tài liệu của Stream Builder .

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

Ca sử dụng

Giả sử chúng ta có luồng nhân viên và chúng ta cần sử dụng luồng này để ghi dữ liệu nhân viên trong tệp excel và sau đó cập nhật bảng / bộ sưu tập nhân viên [Đây chỉ là trường hợp sử dụng để hiển thị việc sử dụng Trình tạo luồng]:

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

Tôi gặp vấn đề tương tự và có thể nghĩ ra ba cấu trúc trung gian khác nhau để tạo bản sao của luồng: a List, mảng và a Stream.Builder. Tôi đã viết một chương trình điểm chuẩn nhỏ, đề xuất rằng từ quan điểm hiệu suất,List chậm hơn khoảng 30% so với hai chương trình khác khá giống nhau.

Hạn chế duy nhất của việc chuyển đổi thành một mảng là rất khó nếu kiểu phần tử của bạn là kiểu chung (trong trường hợp của tôi là như vậy); do đó tôi thích sử dụngStream.Builder .

Tôi đã kết thúc việc viết một hàm nhỏ tạo ra 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);
}

Sau đó, tôi có thể tạo một bản sao của bất kỳ luồng nào strbằng cách làm str.collect(copyCollector())mà cảm thấy khá phù hợp với cách sử dụng thành ngữ của luồng.