重走 Java 基础之 Streams(二)

Processing Order

Stream对象的处理可以是顺序或并行.

在* sequential *模式中，按照“Stream”的源的顺序处理元素。如果Stream是有序的（例如 SortedMap实现或 List ），处理过程保证匹配源的排序。然而，在其他情况下，应注意不要依赖于顺序（参见：是Java的HashMap``keySet()迭代顺序一致？）。

Example:

  List<Integer> integerList = Arrays.asList(0, 1, 2, 3, 42); 

// sequential 
long howManyOddNumbers = integerList.stream()
                                      .filter(e -> (e % 2) == 1).count(); 

  System.out.println(howManyOddNumbers); // Output: 2

Live on Ideone

Parallel(并行)模式允许在多个核上使用多个线程，但不能保证处理元素的顺序。

如果在顺序的Stream上调用多个方法，则不必调用每个方法。例如，如果一个Stream被过滤，并且元素的数量减少到一，则不会发生对诸如sort的方法的后续调用。这可以提高顺序的Stream的性能 - 这是一个并行的Stream不可能实现的优化。
Example:

  // parallel
long howManyOddNumbersParallel = integerList.parallelStream()
                                              .filter(e -> (e % 2) == 1).count();

  System.out.println(howManyOddNumbersParallel); // Output: 2

Live on Ideone

Differences from Containers (or Collections)

虽然一些操作可以在Containers和Streams上执行，但它们最终用于不同的目的并支持不同的操作。容器更注重元素的存储方式以及如何有效地访问这些元素。另一方面，Stream不提供对其元素的直接访问和操纵; 它更专用于作为集体实体的对象组并且作为整体对该实体执行操作。 Stream和Collection是用于这些不同目的的单独的高级抽象。

Consuming Streams

A Stream将仅在有终端操作时被遍历，如 count()， collect() 或forEach()。否则，不会对 Stream 执行任何操作。

在下面的示例中，没有将终端操作添加到Stream，因此 filter() 操作不会调用，并且不会产生输出，因为peek()不是终端操作。

  IntStream.range(1, 10).filter(a -> a % 2 == 0).peek(System.out::println);

Live on Ideone

这是一个具有有效终端操作的 Stream 序列，因此产生一个输出。

你也可以使用forEach而不是peek：

  IntStream.range(1, 10).filter(a -> a % 2 == 0).forEach(System.out::println);

Live on Ideone

Output:

2
4
6
8

在执行终端操作之后， Stream 被执行消耗，不能被重复使用。

一般来说，Stream的操作如下图所示：

NOTE: 即使没有终端操作，也始终执行参数检查：

  try {
      IntStream.range(1, 10).filter(null);
  } catch (NullPointerException e) {
      System.out.println("We got a NullPointerException as null was passed as an argument to filter()");
  }

Live on Ideone

Output:

We got a NullPointerException as null was passed as an argument to filter()

Creating a Frequency Map

groupingBy（classifier，downstream）collector允许将 Stream元素集合通过对组中的每个元素进行分类到一个 Map，并对分类在同一组中的元素执行后续操作。

这个原则的一个典型例子是使用Map 来计算Stream。在这个例子中，分类器是简单的identity函数，它返回元素as-is。后续操作计算等于元素的数量，使用 counting()。

  Stream.of("apple", "orange", "banana", "apple")
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
        .entrySet()
        .forEach(System.out::println);

后续操作本身是一个收集器（Collectors.counting() ），对String类型的元素进行操作，并生成类型为Long的结果。 collect方法调用的结果是一个Map。

This would produce the following output:

banana=1
orange=1
apple=2

Infinite Streams 无限流

可以生成一个不结束的Stream。在无限的Stream上调用终端方法导致Stream进入无限循环。一个Stream的limit方法可以用于限制Java处理的Stream的术语数。

这个例子生成一个所有自然数的Stream，从数字1开始。Stream的每个连续项比上一个高一个。通过调用这个Stream的limit方法，只有Stream的前5个项被考虑和打印。

// Generate infinite stream - 1, 2, 3, 4, 5, 6, 7, ...
IntStream naturalNumbers = IntStream.iterate(1, x -> x + 1);

// Print out only the first 5 terms
naturalNumbers.limit(5).forEach(System.out::println);

Output:

1
2
3
4
5

Collect Elements of a Stream into a Collection 将流的元素收集到集合中

Collect with toList() and toSet()

通过Stream.collect操作可以轻松地将 Stream元素收集到容器中：

System.out.println(Arrays
    .asList("apple", "banana", "pear", "kiwi", "orange")
    .stream()
    .filter(s -> s.contains("a"))
    .collect(Collectors.toList())
);
// prints: [apple, banana, pear, orange]

其他集合实例，例如Set，可以通过使用其他Collectors 内置方法。例如，Collectors.toSet()收集 Stream into到一个 Set中。

Explicit(显式) control over the implementation of List or Set

根据Collectors＃toList（）和 Collectors#toSet()文档，不能保证所返回 List或 Set的类型，可变性，序列化或线程安全。

为了显式控制要返回的实现，可以使用Collectors＃toCollection（Supplier），从而可以返回一个指定类型的新的空集合。

// syntax with method reference
System.out.println(strings
        .stream()
        .filter(s -> s != null && s.length() <= 3)
        .collect(Collectors.toCollection(ArrayList::new))
);

// syntax with lambda
System.out.println(strings
        .stream()
        .filter(s -> s != null && s.length() <= 3)
        .collect(Collectors.toCollection(() -> new LinkedHashSet<>()))
);

Parallel Stream

Note: 在决定使用哪个Stream之前，请先看看ParallelStream vs Sequential Stream的对比.

当你想同时并发执行Stream操作时，你可以使用这些方法。

List<String> data = Arrays.asList("One", "Two", "Three", "Four", "Five");
Stream<String> aParallelStream = data.stream().parallel();

Or:

Stream<String> aParallelStream = data.parallelStream();

要执行为并行流定义的操作，请调用终端运算符：

aParallelStream.forEach(System.out::println);

(A possible) output from the parallel Stream:

Three
Four
One
Two
Five

顺序可能会改变，因为所有的元素被并行处理（这个可能使它更快）。当顺序无关紧要时使用parallelStream。

性能影响

在涉及网络的情况下，并行的 Stream可以降低应用的整体性能，因为所有并行的 Stream对于网络使用公共的fork-join线程池。

另一方面，在许多其他情况下，根据当前运行的CPU中可用内核的数量，并行的 Stream可以显着提高性能。

原文链接：一叶知秋
作者：知秋
[ 转载请保留原文出处、作者。]