引言
Java8 加入了java.util.stream包，这个包中的相关API将极大的增强容器对象对元素的操作能力。
它专注于对集合对象进行各种便利、高效的聚合操作，或大批量数据处理。
Stream API借助于同样新出现的Lambda表达式，极大的提高了编程效率和程序信噪比。
它提供了串行和并行两种模式进行汇聚操作。并行模式底层采用 Fork / Join 框架来拆分任务和加速处理过程。
什么是流？
一、流的概念
1、流不是数据结构
它没有内部存储，它只是用操作管道从source（数据结构、数组、IO channel）抓取数据。
2、不修改源数据
例如Stream 的 filter操作会产生一个不包含被过滤元素的新的Stream，而不是从source中删除那些元素。
3、流的操作参数
所有的Stream操作必须以Lambda表达式作为参数。
4、不支持索引访问
Stream操作实际上是 增强For循环 的函数编程变式，它没有元素下标的访问方式。
5、流可以转换成数组或者List
6、惰性化
Intermediate操作永远是惰性化的
7、并行能力
当一个集合不要求元素的顺序时，我们可以通过Stream的并行化特性来充分利用多核资源，不需要再写多线程代码，所有对它的操作会自动并行进行。
8、可以是无限的
集合有固定大小，Stream则不必，limit(n)、findFirst()这类short-circuiting操作可以对无限的Stream进行运算并很快完成。
二、流的操作分类
流的操作类型被分为三种：Intermediate、Terminal、short-circuiting 。
Intermediate ：代表流的中间操作，这种操作的目的主要是打开流，做出某种程度的映射或过滤，然后返回一个新的流，交给下一个操作使用。这类操作是惰性的，也就是说，仅仅调用到这类方法，并没有真正开始流的遍历。
Terminal ：一个流只能有一个Terminal操作。所以这必定是流的最后一个操作。而Terminal操作的执行，才会真正开始流的遍历，并且会生成一个结果，或者一个副作用。
short-circuiting ：对于Intermediate 操作，如果接收的是一个无限大的Stream，则返回一个有限的新Stream；对于Terminal 操作，如果它接收的是一个无限大的Stream，但能在有限的时间计算出结果。
三、惰性化（lazy）
我们说Intermediate操作都是惰性化的，这如何理解？在对于一个Stream进行多次转换操作（Intermediate操作），每次操作都对Stream中的每个元素进行转换，而且是执行多次，这样时间复杂度就是 N（转换次数）个for循环里所有操作都执行完的总和吗？其实不是这样的！
我们说转换操作是Lazy的，多个转换操作只会在Terminal 操作的时候融合进来，一次循环完成。
我们可以这样简单的类比，在Java 8 未引进Stream API的时候，使用命令式进行for循环，并对每个元素进行诸如 if-else 、赋值、计算、获取、添加等操作，而这些操作你可以理解为Stream中的Intermediate操作，只有在for循环真正执行的时候才会执行它们，这就是惰性化的语义，即提前安排好筛选、计算等Intermediate操作，当循环时再执行它们。
常见用法归纳
一、创建流
我们可以通过一个“集合”对象来创建流，这个集合对象并不限于Collection接口，还包含那些能容纳多个对象的容器。
创建流的方式大致可以分为三种：Arrays.stream()、Stream.of()、集合.stream()，下面举例来说明：
1、数组生成流
// 基本类型数组
int[] numx = new int[] { 1, 2, 2, 3, 5 };
// 方法一：
IntStream stream1 = Arrays.stream(numx);
// 方法二：
IntStream stream2 = IntStream.of(numx);
// 引用类型数组
Integer[] nums = new Integer[] { 1, 2, 2, 3, 5 };
// 方法一：
Stream<Integer> stream3 = Arrays.stream(nums);
// 方法二：
Stream<Integer> stream4 = Stream.of(nums);
需要注意的是，对于基本数值型，目前有三种对应的包装类型 Stream：
IntStream、LongStream、DoubleStream。当然我们也可以用 Stream<Integer>、Stream<Long> >、Stream<Double>，但是 boxing 和 unboxing 会很耗时，所以特别为这三种基本数值型提供了对应的 Stream。 Java 8 中还没有提供其它数值型 Stream，因为这将导致扩增的内容较多。而常规的数值型聚合运算可以通过上面三种 Stream 进行。
2、集合生成流
List<Integer> numsList = Arrays.asList( 1, 2, 2, 3, 5 );
// 使用parallelStream会将List进行分段并行处理，因此处理的顺序是不固定的。
Stream<Integer> parallelStream = numsList.parallelStream();二、流转化为容器(Terminal)
Stream<String> names = Arrays.asList("Tom", "Jerry", "Tim", "Morty").stream();1、Stream转Array
String[] namesArr = names.toArray(String[]::new);2、 Stream转Collection
List<String> list1 = names.collect(Collectors.toList());
// 或
List<String> list2 = names.collect(Collectors.toCollection(ArrayList::new));Set<String> set = names.collect(Collectors.toSet());
Stack<String> stack = names.collect(Collectors.toCollection(Stack::new));3、Stream转String
String str = names.collect(Collectors.joining());// joining()有重载三、映射操作（Intermediate）
map将input stream中的每一个元素，映射成output stream中的另外一个元素(一对一映射)
List<String> output = names.map(String::toUpperCase).collect(Collectors.toList());四、多集合映射操作（Intermediate）
flatMap（功能和map相同，只不过映射是一对多），flatMap 把 input Stream 中的层级结构扁平化，就是将最底层元素抽出来放到一起。
List<String> names1 = Arrays.asList("Tom", "Jerry", "Tim", "Morty");
List<String> names2 = Arrays.asList("Tony", "Jack", "Tina", "Marry");
List<String> collect = Stream.of(names1, names2)
.flatMap(ns -> ns.stream().map(String::toLowerCase))
.collect(Collectors.toList());五、筛选操作（Intermediate）
filter对原始 Stream 进行某项测试，通过测试的元素被留下来生成一个新 Stream。
Integer[] sixNums = { 1, 2, 3, 4, 5, 6 };
Integer[] evens = Stream.of(sixNums).filter(n -> n % 2 == 0).toArray(Integer[]::new);六、循环操作（Terminal）
forEach() 方法接收一个 Lambda 表达式，然后在 Stream 的每一个元素上执行该表达式。
但一般认为，forEach 和常规 for 循环的差异不涉及到性能，它们仅仅是函数式风格与传统 Java 风格的差别.
注意:forEach 不能修改自己包含的本地变量值，也不能用 break/return 之类的关键字提前结束循环。
当需要为多核系统优化时，可以 parallelStream().forEach()。另外一点需要注意，forEach 是 terminal 操作。具有相似功能的 intermediate 操作 peek 可以达到上述目的。
Stream.of("one", "two", "three", "four")
.filter(e -> e.length() > 3)
.peek(e -> System.out.println("Filtered value: " + e))
.map(String::toUpperCase)
.peek(e -> System.out.println("Mapped value: " + e))
.collect(Collectors.toList());七、第一个元素（Terminal）
findFirst是一个 termimal 兼 short-circuiting 操作，它总是返回 Stream 的第一个元素，或者空。
注意，它的返回值类型：Optional。使用Optional的目的是尽可能避免 NullPointerException。它提供的是编译时检查，能极大的降低 NPE 这种 Runtime Exception 对程序的影响。
Optional<String> firstName = names2.stream().findFirst();八、聚合操作（Terminal）
reduce方法的主要作用是把 Stream 元素组合起来。它提供一个起始值（种子），然后依照运算规则（BinaryOperator），和前面 Stream 的第一个、第二个、第 n 个元素组合。从这个意义上说，字符串拼接、数值的 sum、min、max、average 都是特殊的 reduce。
下面代码例如第一个示例的 reduce()，第一个参数（空白字符）即为起始值，第二个参数（String::concat）为 BinaryOperator。这类有起始值的 reduce() 都返回具体的对象。而对于第四个示例没有起始值的 reduce()，由于可能没有足够的元素，返回的是 Optional，请留意这个区别。
// 字符串连接，concat = "ABCD"
String concat = Stream.of("A", "B", "C", "D").reduce("", String::concat);
// 求最小值，minValue = -3.0
double minValue = Stream.of(-1.5, 1.0, -3.0, -2.0).reduce(Double.MAX_VALUE, Double::min);
// 求和，sumValue = 10, 有起始值
int sumValue = Stream.of(1, 2, 3, 4).reduce(0, Integer::sum);
// 求和，sumValue = 10, 无起始值
sumValue = Stream.of(1, 2, 3, 4).reduce(Integer::sum).get();
// 过滤，字符串连接，concat = "ace"
String s = Stream.of("a", "B", "c", "D", "e", "F")
.filter(x -> x.compareTo("Z") > 0)
.reduce("", String::concat);九、limit/skip （Short-circuiting）
limit 返回 Stream 的前面 n 个元素；skip 则是扔掉前 n 个元素（它是由一个叫 subStream 的方法改名而来）。
List<String> persons = new ArrayList<>();
for (int i = 1; i <= 10000; i++) {
persons.add(new String("name" + i));
}
List<String> personNameList = persons.stream()
.map(String::toUpperCase)
.limit(10)
.skip(3)
.collect(Collectors.toList());上述代码是一个有 10000 个元素的 Stream，但在 short-circuiting 操作 limit 和 skip 的作用下，管道中 map 操作指定的toUpperCase()方法的执行次数为 limit 所限定的 10 次，而最终返回结果再跳过前 3 个元素后只有后面 7 个返回。
执行结果：
注意，有一种情况 limit/skip 无法达到 short-circuiting 目的，就是把它们放在 Stream 的排序操作后，原因跟 sorted这个 intermediate 操作有关：此时系统并不知道 Stream 排序后的次序如何，所以 sorted 中的操作看上去就像完全没有被 limit 或者 skip 一样。
十、排序操作（Intermediate）
对 Stream 的排序通过 sorted 进行，它比数组的排序更强之处在于你可以首先对 Stream 进行各类 map、filter、limit、skip 甚至 distinct 来减少元素数量后，再排序，这能帮助程序明显缩短执行时间。
List<String> pList = persons.stream().limit(2).sorted((p1, p2) -> p1.toString().compareTo(p2.toString()))
.collect(Collectors.toList());十一、最大/最小值、去重操作（Intermediate）
min 和 max 的功能也可以通过对 Stream 元素先排序，再 findFirst 来实现，但前者的性能会更好，为 O(n)，而 sorted 的成本是 O(n log n)。同时它们作为特殊的 reduce 方法被独立出来也是因为求最大最小值是很常见的操作。
BufferedReader br = new BufferedReader(new FileReader("c:\\noThisFile.txt"));
int longest = br.lines()
.mapToInt(String::length)
.max().getAsInt();
br.close();
System.out.println(longest);十二、匹配操作（Terminal）
Stream 有三个 match 方法，从语义上说：
allMatch：Stream 中全部元素符合传入的 predicate，返回 true
anyMatch：Stream中只要有一个元素符合传入的 predicate，返回 true
noneMatch：Stream 中没有一个元素符合传入的predicate，返回 true
它们都不是要遍历全部元素才能返回结果。例如 allMatch 只要一个元素不满足条件，就 skip 剩下的所有元素，返回 false。
List<Person> persons = new ArrayList();
persons.add(new Person(1, "name" + 1, 10));
persons.add(new Person(2, "name" + 2, 21));
persons.add(new Person(3, "name" + 3, 34));
persons.add(new Person(4, "name" + 4, 6));
persons.add(new Person(5, "name" + 5, 55));
boolean isAllAdult = persons.stream()
.allMatch(p -> p.getAge() > 18);
System.out.println("All are adult? " + isAllAdult);
boolean isThereAnyChild = persons.stream()
.anyMatch(p -> p.getAge() < 12);
System.out.println("Any child? " + isThereAnyChild);