一、为什么需要流(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方法。
（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 流的操作
流的操作可以分为两大类：可以连接起来的操作称为中间操作，关闭流的操作称为终端操作。
(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
