1. 简介

  本教程志在细致入微、深入底层，你将体验从Stream的创建开始（creation）到并行执行（parallel execution）的完整过程，以此体会Stream API的实际用处。

  为了理解下面的文章，读者需要掌握Java 7基础知识（Lambda表达式、Optional、方法引用）以及熟悉Stream API，如果你并不熟悉它们甚至一无所知，建议你先阅读我们之前的文章-Java8 新特性 以及 Java 8 Streams 介绍。

2. 创建Stream

  创建一个Stream实例有多种方式，每种创建方式对应Stream的一个来源。但单个Stream实例每次创建之后，其来源将无法修改，这意味着Stream实例具备源头不可变性，不过我们却可以从单个源创建多个Stream实例。

2.1 Empty Stream - 空Stream

  方法empty()被用于创建一个Empty Stream：

  Stream<String> streamEmpty  = Stream.empty;

  上述代码段创建的Empty Stream通常被用于避免null对象或零元素对象的streams（streams with no element）返回结果为null：

public Stream<String> streamOf(List<String> list){  return lsit == null || list.isEmpty() ? Stream.empty() : list.streams();
}

2.2 Stream of Collection - 集合Steram

  我们可以创建任意Collection接口衍生类（Collection->List、Set、Queue）的Streams：

Collections<String> collection = Arrays.asList("a", "b", "c");
Stream<Stirng> streamOfCollection = collection.stream();

2.3 Stream of Array - 数组Stream

  接下来的这段代码展示的是数组Stream：

Stream<String> streamOfArray = Stream.of("a", "b", "c");

  当然我们可以先创建熟悉的数组类型，再以它为源创建Stream，而且我们可以选择Stream中包含的元素数量：

String[] arr = new String[]{"a", "b", "c"};
Stream<String> streamOfArrayFull = Arrays.stream(arr);
Stream<String> streamOfArrayPart = Arrays.stream(arr, 1, 3);

2.4 Stream.builder() - 构建器

  当builder被用于指定参数类型时，应被额外标识在声明右侧，否则方法build()将创建一个Stream(Object)实例：

Stream<String> streamBuilder = Stream.<String>builder().add("a").add("b").add("c").build();

2.5 Stream.generator() - 生成器

  方法generator()接受一个供应器Supplier<T>用于元素生成。由于生产流(resulting stream)被定义之后属于无限流（即无止境地不断生产），开发者必须指定stream拥有流的目标大小，否则方法generator()将持续生产直到jvm内存到达顶值（memory limit）：

Stream<String> streamOfGenerated = Stream.generate( () -> "element").limit(10);

  上述代码将创建十个内容为“element”的生成流。

2.6 Stream.iterate() - 迭代器

  另一种创建无限流的方法是通过调用方法iterate()，同样的它也需要使用方法limit()对目标流的元素大小进行限制：

Stream<Integer> streamItreated = Stream.iterate(40, n -> n + 2).limit(20);

  迭代流即采用迭代的方法作为元素生产方式，类似于高中数学中的f(x)，f(f(x))，etc。上述例子中，生成流的第一个元素是迭代器iterate()中的第一个元素40，从第二个元素开始的每个新元素都与上个元素有关，在此例中，生成流中的元素为：40、42、44、...78、80。

2.7 Stream of Primitives - 基元流

  Java8提供了创建三大基础数据类型（int、long、double）stream的方式。由于Stream<T>是一个类接口，我们无法采用泛型传参的方式声明基础数据类型的stream，因此三个特殊的接口就被创造出来了：IntStream、LongStream、DoubleStream。
使用它们能够避免不必要的自动装箱¹以提高生产效率。

IntStream intStream = IntStream.range(1, 3);
LongStream longStream = LongStream.rangeClosed(1, 3);

  方法range(int startInclusive, int endInclusive)创建了一个有序流（从startInclusive到endInclusive）。它使后面的值每个增加1，但却不包括最后一个参数，即此方法的结果是具备上限的。方法rangeClosed(int startInclusive, int endInclusive)与range()大致相同，但它却包含了最后一个值。
这两个方法用于生成三大基本数据类型的stream。

  此外，Java8之后，类Random也提供了拓展方法用于生成基础数据类型的stream。例如，下述代码创建了一个含有三个随机值的DoubleStream：

Random random = new Random();
DoubleStream doubleStream = random.doubles(3);

2.8 Stream of String - 字符串流

  String类型也可以作为生成stream的源，这得益于方法chars()的帮助，此外由于JDK中没有CharStream接口，IntStream也被用来表示字符流（stream of chars）

IntStream streamOfChars = "abc".chars();

  下例中通过特征的正则表达式将一个字符串割裂成（break into）其子串。

Stream<String> streamOfString = 
  Pattern.compile(", ").spitAsStream("a", "b", "c");

2.9 Stream of File - 文件流

  Java NIO²类文件允许通过方法lines()生成文本文件的Stream<String>。文本的每一行都会变成stream的一个元素：

Path path = Paths.get("C:\\file.txt");
Stream<String> streamOfString = Files.lines(path);
Stream<String> streamWithCharset = Files.lines(path, Charset.forName("utf-8"));

ps：在方法lines()中也可以通过Charset设置文件编码。

3. Referencing a Stream - 引用stream

  只要调用生成操作（中间操作）就会实例化一个stream并生成一个可获取的引用，但执行终端操作会使得stream无法访问。为了证明这一点，我们不妨先忘记它，毕竟实践是检验真理的唯一标准。
以下代码如果不考虑冗长的话将是有效的：

Stream<String> stream = Stream.of("a", "b", "c").filter(element -> element.contains("b"));
Optional<String> anyElement = stream.findAny();

  但是倘若我们在执行终端操作后重新使用相同的引用，则会不可避免的触发IllegalStateException。

Optional<String> firstElement = stream.findFirst();

  IllegalStateException是一个运行时异常（RuntimeException），即编译器将不会提示此错误。因此必须记得，JAVA8 不允许重复使用stream
这一设计是合乎逻辑的，因为stream从设计上旨在提供一个将有限操作（指函数体中元素的相关操作）的序列，而不是存储元素。
因此想让以前的代码正常工作我们得先改一改：

List<String> elements =
  Stream.of("a", "b", "c").filter(element -> element.contains("b"))
    .collect(Collectors.toList());
Optional<String> anyElement = elements.stream().findAny();
Optional<String> firstElement = elements.stream().findFirst();

4. Stream Pipeline - 流的管道

  想要执行源数据集的操作集并聚合它们，你需要以下三个部分——源（Source)、中间操作（Intermediate operations）和终结操作（terminal operation）。
中间操作返回的是一个新的可操作stream。举个例子，为了在一个包含少量元素Stream的基础之上新建Stream，我们可以调用方法skip()：

Stream<String> oneModifiedStream = Stream.of("abcd", "bbcd", "cbcd").skip(1);

  如果需要多次修改，则可以采用多次中间操作。假如我们还需要将Stream<String>中每个字符串替换为其子串subString(0, 3)，则可以使用skip()和map()相连的方式完成：

Stream<String> twiceModifiedStream = stream.skip(1).map(element -> element.subString(0, 3));

  正如你所见，上例中map()使用Lambda表达式作为其参数对stream中的各元素进行处理。
stream本身是毫无价值的，编程人员最感兴趣的其实是终结操作（terminal operation），它可以是一个元素也可以是一个行为。只有在终结操作里才能对每个stream进行使用。正确的且最方便的stream操作方式就是Stream Pipeline，即stream源->中间操作->终结操作。如例：

List<String> list = Arrays.asList("abc1", "abc2", "abc3");long size = list.stream().skip(1)
  .map(element -> element.substring(0, 3)).sorted().count();

5. Lazy Invocation - 懒式调用

  中间操作是懒式调用的，这意味着只有在终结操作需要它们的时候中间操作才会被唤醒。
为了证明这个事实，假象我们有个方法wasCalled()，每当它被唤醒时使内部变量counter自增。

private long counter;private void wasCalled() {
  counter++;
}

  接下来让我们在filter()操作中唤起wasCalled():

List<String> list = Arrays.asList(“abc1”, “abc2”, “abc3”);
counter = 0;
Stream<String> stream = list.stream().filter(element -> {
    wasCalled();    return element.contains("2");
});

  由于有三个变量，想象中filter()中的代码块将被执行三次，wasCalled()执行三次之后counter的值应为3，但是执行之后counter并未发生改变，仍然为0，也就是说filter()一次也没有被唤醒，这个原因就是缺失了终结操作（terminal operation）。
那接下来我们不妨再上述代码的基础之上添加一次map()操作和一个终结操作——findFirst()，并采用打日志的方式帮助我们了解方法调用时机及顺序。

Optional<String> stream = list.stream().filter( element -> {    log.info("filter() was called!");    return element.contains("2");
  }).map(element -> {    log.info("map() was called!");    return element.toUpperCase();
  }).findFirst();

  日志结果显示filter()被唤醒了两次，而map()仅仅被调用一次，这是由于管道流是垂直执行的。在此例中第一个元素不满足filter()的要求，因此filter()被调用第二次以查找合适的结果，通过之后即进行map()操作，此时就没有第三次机会执行filter()操作了。findFirst()就能找出源数据集中第一个含有“2”的字符串的全大写字符串了。因此，懒调用使得不必相继调用两个中间操作（filter()和map()）才能完成任务了。

6. Order of Execution - 执行顺序

  从性能的角度考虑，正确的执行顺序是采用上文提到的流式管道（Stream Pipeline）：

long size = list.stream().map(element -> {
    wasCalled();    return element.substring(0, 3);
}).skip(2).count();

  执行这段代码将使counter自增长3次，这意味着stream的方法map()将被调用3次，但最终size的值为1。这意味着结果流（resulting stream）中仅仅只有一个元素，毫无疑问在三次消息处理中程序跳过了两次处理。
如果我们改变skip()和map()的执行顺序，counter将只自增长一次。也即是map()只被调用一次：

long size = list.stream().skip(2).map(element -> {
    wasCalled();    return element.substring(0, 3);
}).count();

  以上示例告诉我们一个规则：用于减少流中元素数量的中间操作，应当放置在处理操作之前。因此，保证在你的Stream Pipeline规则中按照这样的顺序编码：skip() --> filter() --> distinct()

7. Stream Reduction - 流的聚合

  API提供了大量的终端操作用以聚合一个stream为一种数据类型或变量。比如：count()、max()、min()、sum()，但是这些方法都是预定义的。但如果用户需要自定义一个stream的聚合操作呢？官方提供了两个方法用以实现此类需求：reduce() 和 collect()。

7.1 reduce()方法

  此方法提供了三种变种，不同之处是它们的签名以及返回类型。reduce()方法具有下列参数：
identify（标识器） - 累积器的初始值或当stream为空时的默认值。
accumulator（累积器） - 提供设定聚合元素之逻辑的功能，每次规约(reducing)累积器都会创建一个新的值，新值的大小等于stream的大小，并且只有上一个值是可用的。这非常有助于提升性能。
combiner（组合器） - 提供聚合accumulator（累积器）中元素的功能，combiner是唯一一个能从不同线程以并行模式聚合累积器中结果的方法。
好，让我们来实战一下吧：

OptionalInt reduced =
    IntStream.range(1, 4).reduce((a, b) -> a + b);

reduced = 6 = 1 + 2 + 3。

int reducedTwoParams =
    IntStream.range(1, 4).reduce(10, (a, b) -> a + b);

reducedTwoParams = 16 = 10 + 1 + 2 + 3。

int reducedParams = Stream.of(1, 2, 3)
  .reduce(10, (a, b) -> a + b, (a, b) -> {     log.info("combiner was called");     return a + b;
  });

  这一结果与上文中的16一样，并且不会打出日志，因为combiner没有被唤起。为了唤醒combiner，stream应当是并行的：

int reducedParallel = Arrays.asList(1, 2, 3).parallelStream()
    .reduce(10, (a, b) -> a + b, (a, b) -> {       log.info("combiner was called");       return a + b;
    });

  此时，结果变为36，并且combiner被唤起了两次。规约（reduce）运转的算法为：每当stream中的元素通过identify（标识器）时accumulator（累积器）均被调用，最终累积器调用了3次。上述行为是并行完成的，因此造成了（10+1=11; 10+2=12; 10+3=13;）。最终combiner（组合器）混合了三次的结果，通过两次迭代完成运算（12+13=25; 25+11=36;）。

7.2 collect()方法

  stream的规约也可以被其他的终结方法执行——collect()。它接收了一个名为collector的参数，此参数注明规约的流程。官方已经创建了预定义的收集器，我们可以在这些收集器的帮助下访问它们。
下面我们将看到使用List作为所有stream的来源：

List<Product> productList = Arrays.asList(new Product(23, "potatoes"),  new Product(14, "orange"), new Product(13, "lemon"),  new Product(23, "bread"), new Product(13, "sugar"));

转换一个stream为Collection集合（Collection、List、Set、Queue、etc）。

List<String> collectorCollection = 
  productList.stream().map(Product::getName).collect(Collectors.toList());

规约为String类型：

String listToString = productList.stream().map(Product::getName)
  .collect(Collectors.joining(", ", "[", "]"));

  join()方法拥有三个参数（delimiter, prefix, suffix），使用join()最便捷之处在于程序员不需要考虑stream的起始与结束甚至界定符，Collector会考虑到这些的。
计算stream中所有数字元素的平均值

double averagePrice = productList.stream()
  .collect(Collectors.averagingInt(Product::getPrice));

计算stream中所有数字元素的和

int summingPrice = productList.stream()
    .collect(Collectors.summingInt(Product::getPrice));

  方法averagingXX()、summingXX()和summarizingXX()适用于基础数据类型（int,long,double），也适用于它们的封装类（ Integer,Long,Double）。一个很有效的功能技术提供映射，因此开发者也不是一定需要在collect()方法之后使用map()操作才能完成映射的。
收集stream元素集的统计信息：

IntSummaryStatistics statistics = productList.stream()
    .collect(Collectors.summarizingInt(Product::getPrice));

  通过使用IntSummaryStatistics的生成实例，开发者能够通过请求toString()方法创建一个统计报告，结果将是一系列显而易见的结果：IntSummaryStatistics{count=5, sum=86, min=13, average=17,200000, max=23}。通过调用上述方法getCount()、getSum()、getMin()、getAverage()、getMax(),我们也很容易从对象中提取出count、sum、min、average的值，这是因为所有的值均可以从单个管道中获取。

采用指定方法组合stream中的元素:

Map<Integer, List<Product>> collectorMapOfLists = productList.stream()
  .collect(Collectors.groupingBy(Product::getPrice));

  此例中stream将根据group规则将所有元素规约成一个map。
根据一些描述对stream进行分组:

Set<Product> unmodifiableSet = productList.stream()
  .collect(Collectors.collectingAndThen(Collectors.toSet(),  Collections::unmodifiableSet));

  这种相对特殊的情况里，collection将stream转化为一个Set，之后在此基础上创建了一个不可变的Set。

Custome collector（自定义收集器）:
  假若我们因为一些特定的原因需要创建自定义的收集器，那更简介轻快的方法是采用Collection的of()方法：

Collector<Product, ?, LinkedList<Product>> toLinkedList =
  Collector.of(LinkedList::new, LinkedList::add, 
    (first, second) -> { 
       first.addAll(second); 
       return first; 
    });
 
LinkedList<Product> linkedListOfPersons =
  productList.stream().collect(toLinkedList);

  在上例中，Collection的实例被规约成了一个LinkedList<Person>。

Parallel Streams - 并行流

  在Java8之前，并行化十分复杂。ExecutorService和FornJoin的出现大大降低了并行开发的复杂度，但它们都无不避免的关注在如何创建一个特征鲜明的executor，以及如何去运行它等等。Java8提倡了一种新的方式用于在函数类型中实现并行化。
  API提供并行流用以并行化执行操作。当stream的源是一个数组或者Collection时，在parallelStream()方法的帮助下可以实现并行化：

Stream<Product> streamOfCollection = productList.parallelStream();boolean isParallel = streamOfCollection.isParallel();boolean bigPrice = streamOfCollection
  .map(product -> product.getPrice() * 12)
  .anyMatch(price -> price > 200);

但如果stream的源不是数组或者集合类型时，parallel()方法就应该被使用了：

IntStream intStreamParallel = IntStream.range(1, 150).parallel();boolean isParallel = intStreamParallel.isParallel();

上例中，Stream API自动使用了ForkJoin框架去完成并行操作。默认情况下，公共线程池将被使用，不会（至少暂时不会）给它单独分配线程。当stream处于并行状态时，应当注意可能产生阻塞的操作，当对时间效率有所追求且操作可并行时应当转换为并行stream（理由是假如某个任务大小远远多于其他任务，那它将更加耗时）。当然啦，并行模式也可以转换回串行模式，只要使用sequential()方法就能做到这点：

IntStream intStreamSequential = intStreamParallel.sequential();boolean isParallel = intStreamSequential.isParallel();

作者：Yodes
链接：https://www.jianshu.com/p/b464487ff844