Java 8 findFirst并遇到订单

Question

在对JavaDoc中findFirst说,如果流有一个邂逅的命令,那么第一个元素总是会返回,但如果流没有遭遇订单,可以返回的任何元素.

我试图演示它如何在没有遭遇顺序的流上工作,但我不能让它返回除了实际的第一个元素之外的任何东西.

我尝试将元素添加到a Set,它没有定义的遭遇顺序:

    Set<String> words = new HashSet<>();
    words.addAll(Arrays.asList("this", "is", "a", "stream", "of", "strings"));
    Optional<String> firstString = words.stream()
            .findFirst();
    System.out.println(firstString);

每次我跑,我得到a第一个字符串.然后我试图做一个Collections.shuffle关于List它添加到之前Set,但这并没有改变任何东西.

    List<String> wordList = Arrays.asList("this", "is", "a", "stream", "of", "strings");
    words = new HashSet<>();
    words.addAll(wordList);
    firstString = words.stream()
            .findFirst();
    System.out.println(firstString);

我a每次都会回复这个词.

然后我尝试使用unorderedfrom方法BaseStream,声称返回没有遇到顺序的流,但没有区别:

    firstString = Stream.of("this", "is", "a", "stream", "of", "strings")
            .unordered()
            .findFirst();
    System.out.println(firstString);

现在我this每次都得到这个词.我错过了什么吗？有没有办法证明findFirst在无序流上返回不同的值？

Answer 1

好吧,"任何"包括"第一"的可能性.当然,Stream实现不会浪费随机化数据的工作,所以对于很多情况,特别是顺序执行,它仍然是第一个元素,如果我们可以这样调用它(因为没有命令,有没有尊贵的第一元素).

展示不同结果的最佳机会findFirst是使用并行Streams.但即便如此,并非每种操作组合都适合展示无序性.

有一点是,在当前实现中,当Stream无序时,findFirst() 操作不会改变它的行为,即它不会主动尝试findAny().由于Stream 的来源,它仍然可能表现出不可预测的行为,但如果你的源是Stream.of("this", "is", "a", "stream", "of", "strings"),即已知大小的不可变序列,它已经具有最佳的并行性能,所以根本无法获得链接的好处unordered()因此,当前的实现不会改变其行为.

这可能会让人大吃一惊,但这HashSet在一定程度上也适用于某种程度.虽然它有一个未指定的顺序,但在某个时间点它的支持数组中会有一个实际的顺序,只要你不修改它Set,就没有理由将这些条目随机改变,所以对于一个特定的HashSet实例,您可以重复获取相同的"第一个"元素,尽管未指定哪个元素,甚至在单个运行时内,另一个HashSet表示相同内容但具有不同历史记录的实例可能具有不同的顺序.

已知从无序特征中获益的操作的一个示例是distinct.虽然它必须解决重复问题,但它必须保持第一次遇到相同的元素,如果它产生显着的差异.这会显着降低性能,因此,如果流是无序的,实现将立即尝试获得好处.例如

List<String> equal=IntStream.range(0, 100)
    .mapToObj(i->new String("test")) // don't do this in normal code
    .collect(Collectors.toList());
Map<String, Integer> map = IntStream.range(0, equal.size())
    .collect(IdentityHashMap::new, (m,i)->m.put(equal.get(i),i), Map::putAll);

equal.parallelStream().distinct().map(map::get)
     .findFirst().ifPresent(System.out::println);

这会创建一堆equal但可区分的String实例(您通常不应该这样做),将它们的位置编号注册到一个中IdentityHashMap,这样我们就可以找到distinct保留的实例.由于上面的代码使用由a创建的有序流List,因此0无论您多久执行一次,它都会一直打印.

相反,

equal.parallelStream().unordered().distinct().map(map::get)
     .findFirst().ifPresent(System.out::println);

将打印任意数量的范围,因为我们已经发布了有序合同并允许选择任何相等的字符串.

如前所述,这是所有特定于实现的.你永远不应该假设一个操作是否可以实际获得一个好处,从而改变它对无序流的行为.上面的解释只是为了说明为什么有时特定实现的行为可能不会因无序流而改变.但是,它仍然可能在下一个版本或不同的JRE实现中.

Answer 2

霍尔格已经巧妙地解释了这种情况.(+1)我想提供HashSet具有相同内容但具有不同迭代顺序的实例的演示.首先我们像以前一样创建一个集合:

    List<String> wordList = Arrays.asList("this", "is", "a", "stream", "of", "strings");
    Set<String> words = new HashSet<>(wordList);

我们创建另一组单词,添加一堆东西(无论它究竟是什么),然后将其删除:

    Set<String> words2 = new HashSet<>(wordList);
    IntStream.range(0, 50).forEachOrdered(i -> words2.add(String.valueOf(i)));
    words2.retainAll(wordList);

如果我们检查结果如下:

    System.out.println(words.equals(words2));
    System.out.println(words);
    System.out.println(words2);

我们可以从输出中看到集合相等但以不同的顺序迭代:

true
[a, strings, stream, of, this, is]
[this, is, strings, stream, of, a]

如其他地方所述,如果从这些中获取流并调用findFirst(),则结果是迭代顺序中的第一个元素,这些元素在这些集之间明显不同.

发生了什么,通过添加和删除一堆元素,我们已经导致集合增加其内部表大小,需要重新元素的元素.即使在删除了新元素之后,原始元素也会在新表中的不同相对位置结束.

虽然HashSets没有指定的迭代顺序,但如果每次以相同的方式使用相同的内容初始化集合,则顺序可能是可重复的(甚至可预测的).因此,我们说来自集合的流没有定义的遭遇顺序,即使每次的顺序通常相同.

请注意,在JDK 9中,新的不可变集(和映射)实际上是随机的,因此它们的迭代顺序将在不同的运行之间发生变化,即使它们每次都以相同的方式初始化.

Answer 3

通过将您的流标记为无序,您实际上并没有这样做(您没有使您的Set中的顺序有任何不同),而是取消了有序流可能强加的任何限制.

证明这将返回不同结果的方法是使用并行流.

 Set<String> words = new HashSet<>();
    words.addAll(Arrays.asList("this", "is", "a", "stream", "of", "strings"));
    Optional<String> firstString = words.stream().parallel()
            .findFirst();
    System.out.println(firstString);

运行几次,显示:

  Optional[strings] and then Optional[this]

将您的Set更改为List并且并行运行将保留订单:

 List<String> words = new ArrayList<>();
    words.addAll(Arrays.asList("this", "is", "a", "stream", "of", "strings"));
    Optional<String> firstString = words.stream().parallel()
            .findFirst();
    System.out.println(firstString); // always Optional[this]

这里绝对必读的是霍尔格的大答案