《Java8实战》第4章引入流

集合是 Java 中使用最多的 API。

4.1 流是什么

流是 Java API 的新成员，它允许你以声明性方式处理数据集合（通过查询语句来表达，而不是临时编写一个实现）。可以看作是遍历数据集的高级迭代器，而且还可以并行的处理。
例子：返回低热量菜肴名称
Java7的实现

// 用累加器筛选元素
List<Dish> lowCaloricDishes = new ArrayList<>(); 
for(Dish dish: menu) { 
 if(dish.getCalories() < 400) { 
   lowCaloricDishes.add(dish); 
 } 
} 
// 用匿名类对菜肴排序
Collections.sort(lowCaloricDishes, new Comparator<Dish>() { 
 public int compare(Dish dish1, Dish dish2) { 
   return Integer.compare(dish1.getCalories(), dish2.getCalories()); 
 } 
}); 
// 处理排序后的菜名列表
List<String> lowCaloricDishesName = new ArrayList<>(); 
for(Dish dish: lowCaloricDishes) { 
 lowCaloricDishesName.add(dish.getName()); 
}

上面的代码还有一个“垃圾变量”lowCaloricDishes。
Java8的实现

import static java.util.Comparator.comparing; 
import static java.util.stream.Collectors.toList; 
List<String> lowCaloricDishesName = 
       menu.stream()
       .filter(d -> d.getCalories() < 400) // 选出 400 卡路里以下的菜肴
       .sorted(comparing(Dish::getCalories)) // 按照卡路里排序
       .map(Dish::getName) // 提取菜肴的名称
       .collect(toList()); // 将所有名称保存在 List 中

为了利用多核架构并行执行这段代码，你只需要把 stream()换成 parallelStream()
代码清晰可读。filter 的结果被传给了 sorted 方法，再传给 map 方法，最后传给 collect 方法。流水线一样

List<Dish> menu = Arrays.asList( 
 new Dish("pork", false, 800, Dish.Type.MEAT), 
 new Dish("beef", false, 700, Dish.Type.MEAT), 
 new Dish("chicken", false, 400, Dish.Type.MEAT), 
 new Dish("french fries", true, 530, Dish.Type.OTHER), 
 new Dish("rice", true, 350, Dish.Type.OTHER), 
 new Dish("season fruit", true, 120, Dish.Type.OTHER), 
 new Dish("pizza", true, 550, Dish.Type.OTHER), 
 new Dish("prawns", false, 300, Dish.Type.FISH), 
 new Dish("salmon", false, 450, Dish.Type.FISH) ); 
Dish 类的定义是：
public class Dish { 
 private final String name; 
 private final boolean vegetarian; 
 private final int calories; 
 private final Type type; 
 public Dish(String name, boolean vegetarian, int calories, Type type) { 
   this.name = name; 
   this.vegetarian = vegetarian; 
   this.calories = calories; 
   this.type = type; 
 } 
 public String getName() { 
   return name; 
 } 
 public boolean isVegetarian() { 
   return vegetarian; 
 } 
 public int getCalories() { 
   return calories; 
 } 
 public Type getType() { 
   return type; 
 } 
 @Override 
 public String toString() { 
   return name; 
 } 
 public enum Type { MEAT, FISH, OTHER } 
}

接下来会谈到很多模式，比如筛选、切片、查找、匹配、映射和归约。

4.2 流简介

流简短的定义就是“从支持数据处理操作的源生成的元素序列”

元素序列——就像集合一样，流也提供了一个接口，可以访问特定元素类型的一组有序值。集合讲的是数据，流讲的是计算。
源——流会使用一个提供数据的源，比如集合、数组或 I/O 资源。由列表生成的流，其元素顺序与列表一致。
数据处理操作——流的数据处理功能支持类似于数据库的操作，以及函数式编程语言中的常用操作，比如 filter、map、reduce、find、match、sort 等。流操作可以顺序执行，也可以并行执行。
流水线——很多流操作本身会返回一个流，这样多个操作就可以链接起来，构成一个更大的流水线。
内部迭代——与集合使用迭代器进行显式迭代不同，流的迭代操作是在后台进行的。

import static java.util.stream.Collectors.toList; 
List<String> threeHighCaloricDishNames = 
 menu.stream() // 从 menu（菜肴列表）获得流
   .filter(dish -> dish.getCalories() > 300) // 建立操作流水线：首先选出高热量的菜肴
   .map(Dish::getName) // 获取菜名
   .limit(3) // 只选择头三个
   .collect(toList()); // 将结果保存在另一个 List 中
System.out.println(threeHighCaloricDishNames); // 结果是[pork, beef, chicken]

本例先是对 menu 调用 stream 方法，由菜单得到一个流。数据源是菜肴列表（菜单），它给流提供一个元素序列。接下来，对流应用一系列数据处理操作：filter、map、limit 和collect。除了 collect 之外，所有这些操作都会返回另一个流，这样它们就可以接成一条流水线，于是就可以看作对源的一个查询。
最后，collect 操作开始处理流水线，并返回结果（它和别的操作不一样，因为它返回的不是流，在这里是一个 List）。在调用 collect 之前，没有任何结果产生，实际上根本就没有从 menu 里选择元素。你可以这么理解：链中的方法调用都在排队等待，直到调用 collect。
filter——接受一个 Lambda，从流中排除某些元素。在本例中，通过传递 Lambda d -> d.getCalories() > 300，选择出热量超过 300 卡路里的菜肴。
map——接受一个 Lambda，将元素转换成其他形式或提取信息。在本例中，通过传递方法引用 Dish::getName，相当于 Lambda d -> d.getName()，提取了每道菜的菜名。
limit——截断流，使其元素不超过给定数量。
collect——将流转换为其他形式。在本例中，流被转换为一个列表。它看起来有点儿像变魔术，第 6 章会详细解释 collect 的工作原理。现在，你可以把 collect 看作能够接受各种方案作为参数，并将流中的元素累积成为一个汇总结果的操作。这里的toList()就是将流转换为列表的方案。

4.3 流与集合

流就像是一个延迟创建的集合：只有在消费者要求的时候才会计算值
用 DVD 对比在线流媒体的例子展示了流和集合之间的差异。

4.3.1 只能遍历一次

和迭代器类似，流只能遍历一次。遍历完之后，这个流就已经被消费掉了。
流只能消费一次，多次就会抛异常

List<String> title = Arrays.asList("Modern", "Java", "In", "Action"); 
Stream<String> s = title.stream(); 
s.forEach(System.out::println); 
s.forEach(System.out::println); // 抛异常 java.lang.IllegalStateException:流已被操作或关闭

4.3.2 外部迭代与内部迭代

使用 Collection 接口需要用户去做迭代（比如用 for-each），这称为外部迭代。
Stream 库使用内部迭代——它帮你把迭代做了，还把得到的流值存在了某个地方，你只要给出一个函数说要干什么就可以了。
集合：用 for-each 循环外部迭代

List<String> names = new ArrayList<>(); 
for(Dish dish: menu){ // 显式顺序迭代菜单列表
 names.add(dish.getName()); 
}

for-each 还隐藏了迭代中的一些复杂性。for-each 结构是一个语法糖，它背后的东西用 Iterator 对象表达出来会更丑陋。
集合：用背后的迭代器做外部迭代

List<String> names = new ArrayList<>(); 
Iterator<String> iterator = menu.iterator(); 
while(iterator.hasNext()) { // 显示迭代
 Dish dish = iterator.next(); 
 names.add(dish.getName()); 
}

流：内部迭代

List<String> names = menu.stream() 
   .map(Dish::getName) // 用 getName 方法参数化 map，提取菜名
   .collect(toList()); // 开始执行操作流水线；没有迭代！

比如地上有一堆散落的玩具。需要叫孩子收拾
外部迭代一个集合，显式地取出每个项目再加以处理。我们只需要对孩子说，“把地上所有的玩具都放进盒子里”就好了。
内部迭代比较好的原因有两个：第一，孩子可以选择一只手拿娃娃，另一只手拿球；第二，她可以决定先拿离盒子最近的那个东西，然后再拿别的。
内部迭代时，项目可以透明地并行处理，或者以更优化的顺序进行处理，还可以轻松的并行执行，不需我们管理。

测验 4.1：外部迭代与内部迭代
基于你对代码清单 4-1 和代码清单 4-2 中外部迭代的学习，请选择一种流操作来重构下面的代码。
List highCaloricDishes = new ArrayList<>();
Iterator iterator = menu.iterator();
while(iterator.hasNext()) {
Dish dish = iterator.next();
if(dish.getCalories() > 300) {
highCaloricDishes.add(d.getName());
}
}
答案：应该选择使用 filter 模式。
List highCaloricDish = menu.stream() .filter(dish -> dish.getCalories() > 300) .collect(toList());

4.4 流操作

filter、map、limit这些都是中间操作，可以连成一条流水线；
collect 触发流水线执行并关闭它。
可以连接起来的流操作称为中间操作，关闭流的操作称为终端操作。

4.4.1 中间操作

除非流水线上触发一个终端操作，否则中间操作不会执行任何处理。这是因为中间操作一般都可以合并起来，在终端操作时一次性全部处理。
打印流的处理过程

List<String> names = 
 menu.stream() 
 .filter(dish -> { 
 System.out.println("filtering:" + dish.getName()); // 打印当前筛选的菜肴
 return dish.getCalories() > 300; 
 }) 
 .map(dish -> { 
 System.out.println("mapping:" + dish.getName()); // 提取菜名时打印出来
 return dish.getName(); 
 })
 .limit(3) 
 .collect(toList()); 
System.out.println(names); 

输出：
filtering:pork 
mapping:pork 
filtering:beef 
mapping:beef 
filtering:chicken 
mapping:chicken 
[pork, beef, chicken]

尽管很多菜的热量都高于 300 卡路里，但只选出了前三个！这是因为 limit 操作和一种称为短路的技巧，
尽管 filter 和 map 是两个独立的操作，但它们合并到同一次遍历中了（我们把这种技术叫作循环合并）

4.4.2 终端操作

终端操作会从流的流水线生成结果，其结果是任何不是流的值，比如 List、Integer，甚至 void。

测验 4.2：中间操作与终端操作
在下列流水线中，你能找出中间操作和终端操作吗？
long count = menu.stream()
.filter(dish -> dish.getCalories() > 300)
.distinct()
.limit(3)
.count();
答案：流水线中最后一个操作 count 返回一个 long，这是一个非 Stream 的值。因此它是一个终端操作。所有前面的操作，filter、distinct、limit，都是连接起来的，并返回一个 Stream，因此它们是中间操作。