从一个长流创建流 [英] Create stream of streams from one long stream

问题描述

我想根据 Streams 的内容将单个 Stream 拆分为 Streams 的 Stream.生成的 Stream 应该包含原始流数据的一部分.

I want to split a single Stream into a Stream of Streams based on the contents of the Streams. The resulting the Stream should contain part of the original streams' data.

我的实际应用程序更复杂(它将时间间隔列表内的日志行分组)，但我的问题是如何处理流，所以在这里我问一个简化的例子.

My real application is more complex (it is grouping log lines that are within a list of time intervals), but my problem is how to handle the streams, so here I ask about a simplified example.

我希望能够根据重复的相同数字将 Stream<Integer> 拆分为 Stream<Stream<Integer>>，只留下流奇数.

I want to be able split a Stream<Integer> into a Stream<Stream<Integer>> based on the same number being repeated, only leaving the streams with odd numbers.

例如以下流包含:

{1,1,1,2,2,2,3,6,7,7,1,1}

需要产生一个包含以下内容的流:

Would need to result in a stream of streams containing:

{{1,1,1},{3},{7,7},{1,1}}

通过过滤器开始(或结束)我可以省略偶数:

Leaving out the even numbers I can do by starting (or ending) with a filter:

Stream<Integer> input = ...;
Straem<Stream<Integer>> output = input.filter(this::isOdd).someOtherOperation();

这是不受欢迎的，因为这意味着对每个输入值进行两次评估，这是可以接受的，但我宁愿避免这样做.

This is undesired as it would mean evaluating each input value twice, this is acceptable but I would prefer avoiding this.

我当前的解决方案是遍历流的内容并创建一个 List<List<Integer>> 并将其转换为 Stream<Stream<Integer>>.然而，这意味着完整的结果保存在内存中(这对我的应用程序来说是不希望的).

My current solution does this iterating over the contents of the stream and creating a List<List<Integer>> and converting that to a Stream<Stream<Integer>>. However this means the full result is kept in memory (which is undesired for my application).

我也认为我可以通过编写自己的 Iterator 从流中读取来实现这一点，但我不确定这将如何工作.

I also think I would be able to pull this of by writing my own Iterator that reads from the stream, but I am not sure how this would work.

如何根据原始 Stream 的内容将 Stream 转换为 Streams 的 Stream，而不首先将完整结果存储为 Lists 的 List.

How can I convert a Stream into a Stream of Streams based on the contents of the original Stream, without storing the full result in as a List of Lists first.

推荐答案

你可能想实现你自己的 聚合拆分器 来做到这一点.proton-pack 库中已经有类似的东西(第一个链接重定向到在 proton-pack 中实现的那个)).

You may want to implement your own aggregating spliterator to do this. There's already something similar in the proton-pack library (the first link redirects to the one implemented in proton-pack).

请注意，您会得到一个 Stream<List<Integer>>(您可以尝试直接修改实现以具有 Stream<Stream<Integer>>，但您总是需要缓冲少量元素；取决于窗口的大小；以测试是否应该创建新窗口).比如:

Note that you get a Stream<List<Integer>> (you may try to modify the implementation to have a Stream<Stream<Integer>> directly, but you always need to buffer a small amount elements; depending on the window's size; to test whether you should create a new window or not). So for example:

StreamUtils.aggregate(Stream.of(1, 1, 1, 2, 2, 2, 3, 6, 7, 7, 1, 1), 
                      Objects::equals)
           .forEach(System.out::println);

输出:

[1, 1, 1]
[2, 2, 2]
[3]
[6]
[7, 7]
[1, 1]

这篇关于从一个长流创建流的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！