一、为什么需要流(Stream)

我们简单看看使用流的好处吧。下面两段代码都是用来返回低热量的菜肴名称的，并按照卡路里排序，一个是用Java 7写的，另一个是用Java 8的流写的。比 一下
之前(Java 7)

        // 筛选低热量的菜肴
        List<Dish> lowCaloricDishes = new ArrayList<>();
        for (Dish d : menu) {
            if (d.getCalories() < 400) {
                lowCaloricDishes.add(d);
            }
        }

        // 将菜肴按照卡路里进行排序
        Collections.sort(lowCaloricDishes, new Comparator<Dish>() {
            @Override
            public int compare(Dish d1, Dish d2) {
                return Integer.compare(d1.getCalories(), d2.getCalories());
            }
        });

        // 将菜肴列表映射为菜肴名称的列表
        List<String> lowCaloricDishesName = new ArrayList<>();
        for (Dish d : lowCaloricDishes) {
            lowCaloricDishesName.add(d.getName());
        }

在这段代码中，用到了一个变量lowCaloricDishes。它唯一的作用就是作为一次 性的中间容器。可以看出，在java 7中，我们需要显示地处理集合中元素的迭代，这种方式成为外部迭代（比如用for-each、iterator等）。
之后（Java 8）

 List<String> lowCaloricDishesName =
                menu.stream()
                        .filter(d -> d.getCalories() < 400)
                        .sorted(comparing(Dish::getCalories))
                        .map(Dish::getName)
                        .collect(toList()); 

而在java 8中，我们无需处理迭代的细节，只需要声明需要对集合执行的操作即可--Stream库使用内部迭代-它帮你把迭代做了。
使用Stream API可以带来哪些好处呢？
（1）代码更简洁，更易读
代码是以声明性的方式编写的:说明想要完成什么(筛选热量低的菜肴的名称 )而不是说明如何实现一个操作（利用循环和if条件等控制语句）
（2）对集合的不同操作可以灵活地组合
可以把几个基础操作链接起来，来表达复杂的数据处理流水线(在filter后面接上 sorted、map和collect操作，如下图所示)，同时保持代码清晰可读。filter的结果被传给了sorted方法，再传给map方法，最后传给collect方法。

将流操操作连接起来构成流水线.png

（3）支持并行处理，充分利用多核架构
Streams库的内部迭代可以自动选择一种适合硬件的数据表示和并行实现。在上面的例子中，为了利用多核架构并行执行代码，只需要把stream()换成parallelStream(),而无需自己去写任何多线程的代码，陷入任务和synchronized的 漫长而艰苦的斗争。

  List<String> lowCaloricDishesName =
                menu.parallelStream()
                        .filter(d -> d.getCalories() < 400)
                        .sorted(comparing(Dish::getCalories))
                        .map(Dish::getName)
                        .collect(toList()); 

二、流与集合

集合是一个内存中的数据结构， 它包含数据结构中目前所有的值，而流不是数据结构，不保存数据，它是有关算法和计算的。流更像一个高级的迭代器（Iterator），单向，只能遍历一次

三、流的使用

流的使用一般包括三件事:

• 一个数据源(如集合)来执行一个查询;

• 一个中间操作链 ，形成一条流水线
  一个终端操作，执行流水线，并能生成结果

  
  流管道 (Stream Pipeline)的组成.png

3.1 如何创建流

3.1.1 由集合创建流

从上面的介绍我们可以得知，从集合创建流是最常见的创建流的方式。

• Collection.stream()
• Collection.parallelStream()

3.1.2 由值创建流

Stream<String> stream = Stream.of("Java 8 ", "Lambdas ", "In ", "Action"); 
stream.map(String::toUpperCase).forEach(System.out::println);

3.1.3 由数组创建流

int[] numbers = {2, 3, 5, 7, 11, 13};
int sum = Arrays.stream(numbers).sum();

3.1.4 由文件生成流

long uniqueWords = 0;
try (Stream<String> lines = Files.lines(Paths.get("data.txt"), Charset.defaultCharset())) {
    uniqueWords = lines.flatMap(line -> Arrays.stream(line.split(" "))).distinct().count();
} catch (IOException e) {
}

3.1.5 由函数生成流

Stream API提 了两个静态方法来从函数生成流 :Stream.iterate和Stream.generate。这两个操作可以创建所谓的无限流:不像从固定集合创建的流那样有固定大小的流。由iterate和generate产生的流会用给定的函数按需创建值，因此可以无穷无尽地计算下去!一般来说， 应该使用limit(n)来对这种流加以 限制，以免打印无穷多个值。

// 打印0,2,4,6,...,16,18
Stream.iterate(0, n -> n + 2)
      .limit(10)
      .forEach(System.out::println);

//  成一个流，其中有五个0到1之间的随机双精度数
Stream.generate(Math::random)
          .limit(5)
          .forEach(System.out::println);

3.2 流的操作

流的操作可以分为两大类：可以连接起来的操作称为中间操作，关闭流的操作称为终端操作。

中间操作与终端操作.png

(1) 中间操作（Intermediate）
一个流可以后面跟随零个或多个Intermediate操作。其目的主要是打开流，做出某种程度的数据映射/过滤，然后返回一个新的流，交给下一个操作使用。这类操作都是惰性化的（lazy），就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
(2) 终端操作（Terminal）
一个流只能有一个Terminal操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行，才会真正开始流的遍历，其结果是任何不是流的值，比如List、Integer，甚至void。
(3) 短路操作（short-circuiting）
当操作一个无限大的 Stream，而又希望在有限时间内完成操作，则在管道内拥有一个 short-circuiting 操作是必要非充分条件。

• 对于一个 intermediate 操作，如果它接受的是一个无限大（infinite/unbounded）的 Stream，但返回一个有限的新 Stream。
• 对于一个 terminal 操作，如果它接受的是一个无限大的 Stream，但能在有限的时间计算出结果。

常见的操作可以归类如下：

• Intermediate：
  map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
• Terminal：
  forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator
• Short-circuiting：
  anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 limit

在对于一个 Stream 进行多次转换操作 (Intermediate 操作)时，每个Intermediate 操作都会循环遍历一次集合中的元素吗？其实不是这样的。下面的代码从1-10中筛选出小于10的偶数，并只取出前两个：

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        list.stream()
                .filter(i -> {
                    System.out.println(i);
                    return i < 10;
                })
                .map(i -> {
                    System.out.println(i);
                    return i * i;
                })
                .limit(1)
                .collect(Collectors.toList());

执行代码将打印：

from filter:1
from map:1
from filter:2
from map:2

可以看出，尽管filter和map是两个独立的操作，但它们合并到同一次遍历中了，我们把这种技术叫作循环合并。
转换操作都是 lazy 的，多个转换操作只会在 Terminal 操作的时候融合起来，一次循环完成。我们可以这样简单的理解，Stream 里有个操作函数的集合，每次转换操作就是把转换函数放入这个集合中，在 Terminal 操作的时候循环 Stream 对应的集合，然后对每个元素执行所有的函数。

参考链接

1.Java 8 in Action
2.https://www.ibm.com/developerworks/cn/java/j-lo-java8streamapi/index.html