Java流操作在终点的执行顺序[重复]

我一直试图从官方 Java 文档中找到关于 Java 流的明确约定，一旦调用终端操作，处理元素并调用中间操作。

例如，让我们看一下这些同时使用 Java 流版本和普通迭代版本的示例（两者产生相同的结果） .

示例1：

    List<Integer> ints = Arrays.asList(1, 2, 3, 4, 5);
    Function<Integer, Integer> map1 = i -> i;
    Predicate<Integer> f1 = i -> i > 2;

    public int findFirstUsingStreams(List<Integer> ints){
        return ints.stream().map(map1).filter(f1).findFirst().orElse(-1);
    }

    public int findFirstUsingLoopV1(List<Integer> ints){
        for (int i : ints){
            int mappedI = map1.apply(i);
            if ( f1.test(mappedI) ) return mappedI;
        }
        return -1;
    }

    public int findFirstUsingLoopV2(List<Integer> ints){
        List<Integer> mappedInts = new ArrayList<>( ints.size() );

        for (int i : ints){
            int mappedI = map1.apply(i);
            mappedInts.add(mappedI);
        }

        for (int mappedI : mappedInts){
            if ( f1.test(mappedI) ) return mappedI;
        }
        return -1;
    }

Java流会进来吗findFirstUsingStreams之后的方法findFirst被称为运行map1按照中描述的顺序findFirstUsingLoopV1 (map不适用于所有元素）或如中所述findFirstUsingLoopV2 (map为所有元素运行）？

这个顺序在 Java 的未来版本中会改变吗？或者有一个官方文档可以保证我们的顺序map1 calls?

示例2：

Predicate<Integer> f1 = i -> i > 2;
Predicate<Integer> f2 = i -> i > 3;


public List<Integer> collectUsingStreams(List<Integer> ints){
    return ints.stream().filter(f1).filter(f2).collect( Collectors.toList() );
}

public List<Integer> collectUsingLoopV1(List<Integer> ints){
    List<Integer> result = new ArrayList<>();
    for (int i : ints){
        if ( f1.test(i) && f2.test(i) ) result.add(i);
    }
    return result;
}

public List<Integer> collectUsingLoopV2(List<Integer> ints){
    List<Integer> result = new ArrayList<>();
    for (int i : ints){
        if ( f2.test(i) && f1.test(i) ) result.add(i);
    }
    return result;
}

Java 流将再次传入collectUsingStreams之后的方法collect被称为运行f1 and f2按照中描述的顺序collectUsingLoopV1 (f1之前评估过f2）或如中所述collectUsingLoopV2 (f2之前评估过f1)?

这个顺序在 Java 的未来版本中会改变吗？或者有一个官方文档可以保证我们的顺序f1 and f2 calls?

Edit

感谢您的所有答案和评论，但不幸的是，我仍然没有看到有关处理元素的顺序的良好解释。文档确实说将为列表保留遇到顺序，但他们没有指定如何处理这些元素。例如，如果findFirst该文档保证map1首先会看到 1 然后是 2 但它并没有说map14 和 5 不会被执行。这是否意味着我们不能保证我们的处理顺序将与我们期望的 Java 未来版本一样？可能是。

这个顺序在 Java 的未来版本中会改变吗？或者有官方文档可以保证我们调用 map1 的顺序吗？

javadoc，包括包摘要（人们经常以某种方式忽略这些）是 API 合约。可观察但未由 javadoc 定义的行为通常应被视为实现细节，该细节可能在未来版本中发生更改。

因此，如果在 javadoc 中找不到它，则无法保证。

未指定流管道阶段的调用和交错顺序。所规定的是在什么情况下所谓的遭遇顺序流被保留。假设有序流，仍然允许实现执行任何交错、批处理和内部重新排序，以保留遇到顺序。例如。 Asorted(comparator).filter(predicate).findFirst()可以在内部替换为filter(predicate).min(comparator)这当然会显着影响谓词和比较器的调用方式，但会产生相同的结果，即使在有序流中也是如此。

这是否意味着我们不能保证我们的处理顺序将符合我们对 Java 未来版本的预期？可能是。

是的，这应该不是问题，因为大多数流 API要求回调是无国籍的 and 无副作用，这意味着他们不应该关心流管道的内部执行顺序，并且结果应该是相同的，以无序流授予的余地为模。

明确的要求和缺乏保证为 JDK 开发人员提供了如何实现流的灵活性。

如果您考虑到任何特定情况，这很重要，您应该提出一个更具体的问题，关于您想要避免的执行重新排序。

您应该始终记住流可以是并行的，例如由第 3 方代码传递的实例，或包含源或中间流操作，该操作比理论上的惰性要少（目前flatMap就是这样的操作）。如果有人提取并重新包装分割器或使用自定义实现，流管道还可以包含自定义行为Stream 界面.

因此，虽然特定的流实现可能会在您以特定方式使用它们时表现出一些可预测的行为，并且该特定情况的未来优化可能被认为极不可能，但这并不能推广到所有可能的流管道，因此 API 无法提供此类一般保证。