为什么Java没有中间合并操作？

Question

注意：我不一定要寻找下面描述的具体示例问题的解决方案。我真的很感兴趣，为什么这在java 8中是不可能的。

Java流是懒惰的。最后，他们有一个单一的终端操作<我的解释是，这个终端操作将通过流提取所有值。没有任何中间操作可以做到这一点。为什么没有中间操作通过流拉入任意数量的元素？类似这样：

stream
    .mapMultiple(this::consumeMultipleElements) // or groupAndMap or combine or intermediateCollect or reverseFlatMap
    .collect(Collectors.toList());

当下游操作尝试推进流一次时，中间操作可能尝试多次（或根本不推进）上游。

我会看到几个用例：
（这些只是示例。所以您可以看到处理这些用例当然是可能的，但它“不是流式方式”，并且这些解决方案缺乏Streams所具有的理想的惰性属性。）

>

将多个元素组合成一个新元素，然后传递到流的其余部分。（例如，配对<代码>（1,2,3,4,5,6）➔ （（1,2）、（3,4）、（5,6）））

// Something like this,
// without needing to consume the entire stream upfront,
// and also more generic. (The combiner should decide for itself how many elements to consume/combine per resulting element. Maybe the combiner is a Consumer<Iterator<E>> or a Consumer<Supplier<E>>)
public <E, R> Stream<R> combine(Stream<E> stream, BiFunction<E, E, R> combiner) {
    List<E> completeList = stream.collect(toList());
    return IntStream.range(0, completeList.size() / 2)
        .mapToObj(i -> combiner.apply(
                completeList.get(2 * i),
                completeList.get(2 * i + 1)));
}

确定流是否为空（将流映射到可选的非空流）

// Something like this, without needing to consume the entire stream
public <E> Optional<Stream<E>> toNonEmptyStream(Stream<E> stream) {
    List<E> elements = stream.collect(toList());
    return elements.isEmpty()
        ? Optional.empty()
        : Optional.of(elements.stream());
}

具有不终止流的惰性迭代器（允许基于更复杂的逻辑跳过元素，然后只跳过（长n）。

Iterator<E> iterator = stream.iterator();
// Allow this without throwing a "java.lang.IllegalStateException: stream has already been operated upon or closed"
stream.collect(toList());

当他们设计流及其周围的一切时，他们是忘记了这些用例还是明确地忽略了这一点<我理解，在处理并行流时，这些可能会产生意外的结果，但在我看来，这是一种可以记录的风险。

Answer 1

并非每个终端操作都会“通过流提取所有值”。终端操作iterator（）和spliterator（）不会立即获取所有值并允许执行延迟处理，包括再次构建新的Stream。对于后者，强烈建议使用spliterator（），因为这允许将更多元信息传递给新流，也意味着减少对象的包装。

E、 g.您的第二个示例可以实现为

public static <T> Stream<T> replaceWhenEmpty(Stream<T> s, Supplier<Stream<T>> fallBack) {
    boolean parallel = s.isParallel();
    Spliterator<T> sp = s.spliterator();
    Stream.Builder<T> firstElement;
    if(sp.getExactSizeIfKnown()==0 || !sp.tryAdvance(firstElement=Stream.builder())) {
        s.close();
        return fallBack.get();
    }
    return Stream.concat(firstElement.build(), StreamSupport.stream(sp, parallel))
                 .onClose(s::close);
}

对于你的一般性问题，我不知道这些示例的一般抽象应该是什么样子，除了已经存在的spliterator（）方法。正如文件所说

然而，如果提供的流操作不提供所需的功能，则基流。迭代器（）和BaseStream。spliterator（）操作可用于执行受控遍历。

Answer 2

您想要的所有操作实际上都可以在流API中实现，但不是现成的。

将多个元素组合成一对元素-您需要一个自定义的拆分器。塔吉尔·瓦列夫正在做这件事。他拥有一个名为StreamEx的绝对强大的库，它可以做许多其他现成不支持的有用的事情。

我不理解你的第二个例子，但我打赌它也是可行的。

跳过到更复杂的操作是在java-9中通过以谓词为输入的dropAnd和takANG。

请注意，当您说中间操作都不能做到这一点时，这是不准确的-有排序的和不同的。否则他们无法工作。还有类似的flatMap，但这更像是一个bug。

还有一件事是，并行流的中间操作没有定义的顺序，因此这种有状态的中间操作将具有并行流的未知项。另一方面，你总是可以选择滥用以下内容：

List<Something> list = Collections.synchronizedList()
.map(x -> {
     list.add(x);
     // your mapping
 })

如果我是你，我不会那么做，如果我真的需要的话，但以防万一。。。