stream.parallel（）不更新spliterator的特性吗？

Question

这个问题是基于这个问题的答案，stream.of和intstream.range之间的区别是什么？

IntStream.range(0, 4)
         .peek(e -> System.out.println(e))
         .sorted()
         .findFirst();

System.out.println(
    IntStream.range(0, 4)
             .spliterator()
             .hasCharacteristics(Spliterator.SORTED)
);

IntStream.range(0, 4)
         .parallel()
         .peek(e -> System.out.println(e))
         .sorted()
         .findFirst();

这将按任何顺序生成如下内容：

2
0
1
3

因此，我希望sorted属性已经被删除，原因是parallel（）。但是，下面的代码也返回true。

System.out.println(
    IntStream.range(0, 4)
             .parallel()
             .spliterator()
             .hasCharacteristics(Spliterator.SORTED)
);

为什么parallel（）不更改sorted属性，并且由于打印了所有四个数字，那么即使sorted属性仍然存在，Java又如何知道流没有排序呢？

Answer 1

具体如何做到这一点是一个非常具体的实现细节。您必须深入挖掘源代码才能真正了解原因。基本上，并行和顺序管道的处理方式不同。看看abstractPipeline.evaluate，它检查isParallel()，然后根据管道是否并行执行不同的操作。

    return isParallel()
           ? terminalOp.evaluateParallel(this, sourceSpliterator(terminalOp.getOpFlags()))
           : terminalOp.evaluateSequential(this, sourceSpliterator(terminalOp.getOpFlags()));

然后查看sortedops.ofint，您将看到它重写了两个方法：

@Override
public Sink<Integer> opWrapSink(int flags, Sink sink) {
    Objects.requireNonNull(sink);

    if (StreamOpFlag.SORTED.isKnown(flags))
        return sink;
    else if (StreamOpFlag.SIZED.isKnown(flags))
        return new SizedIntSortingSink(sink);
    else
        return new IntSortingSink(sink);
}

@Override
public <P_IN> Node<Integer> opEvaluateParallel(PipelineHelper<Integer> helper,
                                               Spliterator<P_IN> spliterator,
                                               IntFunction<Integer[]> generator) {
    if (StreamOpFlag.SORTED.isKnown(helper.getStreamAndOpFlags())) {
        return helper.evaluate(spliterator, false, generator);
    }
    else {
        Node.OfInt n = (Node.OfInt) helper.evaluate(spliterator, true, generator);

        int[] content = n.asPrimitiveArray();
        Arrays.parallelSort(content);

        return Nodes.node(content);
    }
}

如果opwrapsink是一个顺序管道，则最终将调用它；如果它是一个并行流，则将调用opevaluateParallel（顾名思义）。请注意，如果管道已经排序，opwrapsink不会对给定的接收器执行任何操作（只是不加更改地返回它），但opevaluateParallex总是计算拆分器。

还要注意，并行性和排序性并不是相互排斥的。您可以拥有一个具有这些特性的任意组合的流。

“排序”是拆分器的一个特征。从技术上讲，它不是流的特征（就像“Parallel”一样）。当然，parallex可以创建一个具有全新特性的全新分裂器（从原始分裂器获取元素）的流，但为什么要这样做呢？Id想象一下，在任何情况下，您都必须以不同的方式处理并行流和顺序流。