36

我已经阅读了这个和这个问题，但仍然怀疑观察到的行为是否Stream.skip是 JDK 作者的意图。

让我们简单地输入数字 1..20：

List<Integer> input = IntStream.rangeClosed(1, 20).boxed().collect(Collectors.toList());

现在让我们创建一个并行流，以不同的方式组合unordered()with并收集结果：skip()

System.out.println("skip-skip-unordered-toList: "
        + input.parallelStream().filter(x -> x > 0)
            .skip(1)
            .skip(1)
            .unordered()
            .collect(Collectors.toList()));
System.out.println("skip-unordered-skip-toList: "
        + input.parallelStream().filter(x -> x > 0)
            .skip(1)
            .unordered()
            .skip(1)
            .collect(Collectors.toList()));
System.out.println("unordered-skip-skip-toList: "
        + input.parallelStream().filter(x -> x > 0)
            .unordered()
            .skip(1)
            .skip(1)
            .collect(Collectors.toList()));

过滤步骤在这里基本上什么都不做，但给流引擎增加了更多的困难：现在它不知道输出的确切大小，因此关闭了一些优化。我有以下结果：

skip-skip-unordered-toList: [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
// absent values: 1, 2
skip-unordered-skip-toList: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 18, 19, 20]
// absent values: 1, 15
unordered-skip-skip-toList: [1, 2, 3, 4, 5, 6, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20]
// absent values: 7, 18

结果完全没问题，一切都按预期工作。在第一种情况下，我要求跳过前两个元素，然后以不特定顺序收集到列表。在第二种情况下，我要求跳过第一个元素，然后变成无序并再跳过一个元素（我不在乎哪个元素）。在第三种情况下，我首先进入无序模式，然后跳过两个任意元素。

让我们跳过一个元素并以无序模式收集到自定义集合。我们的自定义集合将是HashSet：

System.out.println("skip-toCollection: "
        + input.parallelStream().filter(x -> x > 0)
        .skip(1)
        .unordered()
        .collect(Collectors.toCollection(HashSet::new)));

输出令人满意：

skip-toCollection: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
// 1 is skipped

所以总的来说，我希望只要流是有序的，skip()就跳过第一个元素，否则它会跳过任意​​元素。

但是，让我们使用等效的无序终端操作collect(Collectors.toSet())：

System.out.println("skip-toSet: "
        + input.parallelStream().filter(x -> x > 0)
            .skip(1)
            .unordered()
            .collect(Collectors.toSet()));

现在输出是：

skip-toSet: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20]
// 13 is skipped

forEach任何其他无序终端操作（如、findAny、anyMatch等）都可以实现相同的结果。在这种情况下删除unordered()步骤不会改变任何事情。似乎虽然unordered()step 正确地使流从当前操作开始无序，但无序的终端操作使整个流从一开始就无序，尽管如果skip()使用这会影响结果。这对我来说似乎完全误导：我希望使用无序收集器与在终端操作之前将流转换为无序模式并使用等效的有序收集器相同。

所以我的问题是：

  1. 这种行为是有意的还是一个错误？
  2. 如果是，它是否记录在某处？我已阅读Stream.skip()文档：它没有说明无序终端操作。此外， Characteristics.UNORDERED文档不是很容易理解，也没有说整个流的排序都会丢失。最后，包装摘要中的订购部分也不涵盖这种情况。可能我错过了什么？
  3. 如果打算无序的终端操作使整个流无序，为什么unordered()step 仅从这一点开始使其无序？我可以依靠这种行为吗？还是我很幸运，我的第一个测试运行良好？
4

2 回答 2

30

回想一下，流标志（ORDERED、SORTED、SIZED、DISTINCT）的目标是启用操作以避免做不必要的工作。涉及流标志的优化示例有：

  • 如果我们知道流已经排序，那么sorted()就是空操作；
  • 如果我们知道流的大小，我们可以在 中预先分配一个大小正确的数组toArray()，避免复制；
  • 如果我们知道输入没有有意义的遭遇顺序，我们不需要采取额外的步骤来保持遭遇顺序。

管道的每个阶段都有一组流标志。中间操作可以注入、保留或清除流标志。例如，过滤保留 sorted-ness / distinct-ness 但不保留 size-ness；映射保留大小，但不保留排序或独特性。排序注入排序性。中间操作的标志处理相当简单，因为所有决策都是本地的。

终端操作的标志处理更加微妙。ORDERED 是与终端操作最相关的标志。如果终端操作是无序的，那么我们会反向传播无序性。

我们为什么要做这个？好吧，考虑这个管道：

set.stream()
   .sorted()
   .forEach(System.out::println);

由于forEach不限于按顺序操作，所以对列表进行排序的工作完全是白费力气。所以我们反向传播这个信息（直到我们遇到一个短路操作，例如limit），以免失去这个优化机会。同样，我们可以使用无序流的优化实现distinct。

这种行为是有意的还是一个错误？

是的:) 反向传播是有意的，因为它是一种有用的优化，不应该产生不正确的结果。然而，错误部分是我们正在传播过去skip，这是我们不应该的。所以 UNORDERED 标志的反向传播过于激进，这是一个错误。我们将发布一个错误。

如果是，它是否记录在某处？

它应该只是一个实现细节；如果正确实施，您不会注意到（除了您的流更快。）

于 2015-06-18T12:58:44.010 回答
1

@Ruben，你可能不明白我的问题。大致问题是：为什么 unordered().collect(toCollection(HashSet::new)) 的行为与 collect(toSet()) 不同。当然我知道 toSet() 是无序的。

可能，但是，无论如何，我会再试一次。

看一下收集器 toSet 和toCollection的 Javadocs，我们可以看到toSet提供了一个无序收集器

这是一个 {@link Collector.Characteristics#UNORDERED unordered} 收集器。

即，具有UNORDERED特征的CollectorImpl 。查看 Collector.Characteristics#UNORDERED 的 Javadoc，我们可以阅读：

表示集合操作不承诺保留输入元素的遇到顺序

在 Collector 的 Javadocs 中我们还可以看到：

对于并发收集器，实现可以自由（但不要求）同时实现归约。并发减少是从多个线程同时调用累加器函数的一种方法，使用相同的并发可修改结果容器，而不是在累加期间保持结果隔离。仅当收集器具有 {@link Characteristics#UNORDERED} 特征或原始数据无序时，才应应用并发减少

这对我来说意味着，如果我们设置UNORDERED特性，我们根本不关心流的元素传递给累加器的顺序，因此，可以以任何顺序从管道中提取元素.

顺便说一句，如果您在示例中省略 unordered()，您将获得相同的行为：

    System.out.println("skip-toSet: "
            + input.parallelStream().filter(x -> x > 0)
                .skip(1)
                .collect(Collectors.toSet()));

此外，Stream 中的 skip() 方法给了我们一个提示：

虽然 {@code skip()} 在顺序流管道上通常是一种便宜的操作，但在有序并行管道上可能相当昂贵

和

使用无序流源（例如 {@link #generate(Supplier)}）或使用 {@link #unordered()} 删除排序约束可能会显着加快速度

使用时

Collectors.toCollection(HashSet::new)

您正在创建一个普通的“有序”收集器（一个没有 UNORDERED 特征的），对我来说意味着您确实关心排序，因此，元素被按顺序提取并且您得到预期的行为。

于 2015-06-17T05:49:28.053 回答