函数式编程优势
- “函数第一位”，即函数可以出现在任何地方。
- 可以把函数作为参数传递给另一个函数，还可以将函数作为返回值。
- 让代码的逻辑更清晰更优雅。
- 减少了可变量(Immutable Variable)的声明，程序更为安全。
- 支持惰性计算。
Lambda语法三部分
- 一个括号内用逗号分隔的形式参数，参数是函数式接口里面方法的参数
- 一个箭头符号：->
- 方法体，可以是表达式和代码块，方法体函数式接口里面方法的实现，如果是代码块，则必须用{}来包裹起来，且需要一个return 返回值，但有个例外，若函数式接口里面方法返回值是void，则无需{}。例如：
- (parameters) -> expression 或者 (parameters) -> { statements; }
方法引用是lambda表达式的一个简化写法，所引用的方法其实是lambda表达式的方法体实现，语法也很简单，左边是容器（可以是类名，实例名），中间是“::”，右边是相应的方法名。如下所示：
ObjectReference::methodName
一般方法的引用格式是：
- 如果是静态方法，则是ClassName::methodName。如 Object ::equals
- 如果是实例方法，则是Instance::methodName。如Object obj=new Object();obj::equals;
- 构造函数.则是ClassName::new
Stream是什么
Stream是Java8中新加入的api，更准确的说: Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作 。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。
以前我们处理复杂的数据只能通过各种for循环，不仅不美观，而且时间长了以后可能自己都看不太明白以前的代码了，但有Stream以后，通过filter，map，limit等等方法就可以使代码更加简洁并且更加语义化。 Stream的效果就像上图展示的它可以先把数据变成符合要求的样子（map），吃掉不需要的东西（filter）然后得到需要的东西（collect）。
Stream操作分类
Stream上的所有操作分为两类：中间操作和结束操作，中间操作只是一种标记，只有结束操作才会触发实际计算。中间操作又可以分为无状态的(Stateless)和有状态的(Stateful)，无状态中间操作是指元素的处理不受前面元素的影响，而有状态的中间操作必须等到所有元素处理之后才知道最终结果，比如排序是有状态操作，在读取所有元素之前并不能确定排序结果；结束操作又可以分为短路操作和非短路操作，短路操作是指不用处理全部元素就可以返回结果，比如找到第一个满足条件的元素。之所以要进行如此精细的划分，是因为底层对每一种情况的处理方式不同。
Stream API等价实现
求出字符串集合中所有以字母A开头字符串的最大长度
int longest = 0; for(String str : strings){ if(str.startsWith("A")){// 1. filter(), 保留以A开头的字符串 int len = str.length();// 2. mapToInt(), 转换成长度 longest = Math.max(len, longest);// 3. max(), 保留最长的长度 } }
int longest = strings.stream() .filter(str -> str.startsWith("A")) .mapToInt(str -> str.length()) //.mapToInt(String::length) .max();
Stream串行与并行
Stream可以分为串行与并行两种，串行流和并行流差别就是单线程和多线程的执行。 default Stream stream() ： 返回串行流 default Stream parallelStream() ： 返回并行流 stream()和parallelStream()方法返回的都是java.util.stream.Stream<E>类型的对象，说明它们在功能的使用上是没差别的。唯一的差别就是单线程和多线程的执行。
Stream性能总结
1.对于简单操作，比如最简单的遍历，Stream串行API性能明显差于显示迭代，但并行的Stream API能够发挥多核特性。
2.对于复杂操作，Stream串行API性能可以和手动实现的效果匹敌，在并行执行时Stream API效果远超手动实现。
所以，如果出于性能考虑：
- 对于简单操作推荐使用外部迭代手动实现。
- 对于复杂操作，推荐使用Stream API。
- 在多核情况下，推荐使用并行Stream API来发挥多核优势。
- 单核情况下不建议使用并行Stream API。 如果出于代码简洁性考虑，使用Stream API能够写出更短的代码。即使是从性能方面说，尽可能的使用Stream API也另外一个优势，那就是只要Java Stream类库做了升级优化，代码不用做任何修改就能享受到升级带来的好处。
Stream 来源
所有流计算都有一种共同的结构：它们具有一个流来源、0 或多个中间操作，以及一个终止操作。流的元素可以是对象引用 (Stream<String>)，也可以是原始整数 (IntStream)、长整型 (LongStream) 或双精度 (DoubleStream)。
因为 Java 程序使用的大部分数据都已存储在集合中，所以许多流计算使用集合作为它们的来源。JDK 中的 Collection 实现都已增强，可充当高效的流来源。但是，还存在其他可能的流来源，比如数组、生成器函数或内置的工厂（比如数字范围），而且可以编写自定义的流适配器，以便可以将任意数据源充当流来源。如上图中一些流生成方法。
Stream 操作
中间操作负责将一个流转换为另一个流，中间操作包括 filter()（选择与条件匹配的元素）、map()（根据函数来转换元素）、distinct()（删除重复）、limit()（在特定大小处截断流）和 sorted()。一些操作（比如 mapToInt()）获取一种类型的流并返回一种不同类型的流。
中间操作始终是惰性的：调用中间操作只会设置流管道的下一个阶段，不会启动任何操作。重建操作可进一步划分为无状态 和有状态 操作。无状态操作（比如 filter() 或 map()）可独立处理每个元素，而有状态操作（比如 sorted() 或 distinct()）可合并以前看到的影响其他元素处理的元素状态。
数据集的处理在执行终止操作时开始，比如缩减（sum() 或 max()）、应用 (forEach()) 或搜索 (findFirst()) 操作。终止操作会生成一个结果或副作用。执行终止操作时，会终止流管道，如果您想再次遍历同一个数据集，可以设置一个新的流管道。如下给出了一些终止流操作。
Stream 流与集合比较
集合是一种数据结构，它的主要关注点是在内存中组织数据，而且集合会在一段时间内持久存在。 流的关注点是计算，而不是数据。流没有为它们处理的元素提供存储空间，而且流的生命周期更像一个时间点 — 调用终止操作。 不同于集合，流也可以是无限的（Stream.generate、Stream.iterate）；相应地，一些操作（limit()、findFirst()）是短路，而且可在无限流上运行有限的计算。 程序 = 数据结构 + 算法，集合即数据结构，流操作相当于算法。
数据形式：集合是一个内存中的数据结构，它包含数据结构中目前所有的值——集合中的每个元素都得先算出来才能添加到集合中。（你可以往集合里加东西或者删东西，但是不管什么时候，集合中的每个元素都是放在内存里的，元素都得先算出来才能成为集合的一部分。） 相比之下，流则是在概念上固定的数据结构（你不能添加或删除元素），其元素则是按需计算的。
迭代方式：使用Collection接口需要用户去做迭代（比如用for-each），这称为外部迭代。相反，Streams库使用内部迭代——它帮你把迭代做了，还把得到的流值存在了某个地方，你只要给出一个函数说要干什么就可以了。Steams库的内部迭代可以自动选择一种适合你硬件的数据表示和并行实现。
Stream 基本使用
filter筛选（中间操作）
输出：4,5
List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().filter(i -> i > 3);
distinct去重（中间操作）
输出：1,2,3,4,5
List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().distinct();
limit限制（中间操作）
输出：1,1,2
List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().limit(3);
skip跳过（中间操作）
输出：2,3,4,5
List<Integer> integerList = Arrays.asList(1, 1, 2, 3, 4, 5);
Stream<Integer> stream = integerList.stream().skip(2);
map流映射（中间操作）
输出：6, 7, 2, 6
List<String> stringList = Arrays.asList("Java 8", "Lambdas", "In", "Action");
Stream<Integer> stream = stringList.stream().map(String::length);
flatMap流转换（中间操作）
输出：1, 2, 3, 4
将一个流中的每个值都转换为另一个流
List<List<Integer>> lists = new ArrayList<List<Integer>>() {{ add(Arrays.asList(1, 2)); add(Arrays.asList(3, 4)); }}; Stream<Integer> stream = lists.stream().flatMap(List::stream); //Stream<Integer> stream = lists.stream().flatMap(list -> list.stream());
allMatch匹配所有（中间操作）
输出：
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5); if (integerList.stream().allMatch(i -> i > 3)) { System.out.println("值都大于3"); }
noneMatch全部不匹配（中间操作）
输出：
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5); if (integerList.stream().noneMatch(i -> i > 3)) { System.out.println("值都小于3"); }
anyMatch匹配其中一个（中间操作）
输出：存在大于3的值
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5); if (integerList.stream().anyMatch(i -> i > 3)) { System.out.println("存在大于3的值"); }
findFirst查找第一个（终端操作）
输出：4
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5);
Optional<Integer> result = integerList.stream().filter(i -> i > 3).findFirst();
findAny随机查找一个（终端操作）
输出：存在大于3的值
和findFirst操作相比，并行流优势更大
List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5); if (integerList.stream().findAny(i -> i > 3)) { System.out.println("存在大于3的值"); }
Stream 常用统计
List<Integer> ints = Arrays.asList(1, 1, 2, 2, 3); //统计流中元素个数 ints.stream().count(); ints.stream().collect(Collectors.counting()); //获取流中最小值 ints.stream().min(Integer::compareTo); ints.stream().collect(Collectors.minBy(Integer::compareTo)); //获取流中最大值 ints.stream().max(Integer::compareTo); ints.stream().collect(Collectors.maxBy(Integer::compareTo)); //求和 ints.stream().mapToInt(Integer::intValue).sum(); ints.stream().collect(Collectors.summingInt(Integer::intValue)); ints.stream().reduce(0, Integer::sum); //平均值 ints.stream().collect(Collectors.averagingInt(Integer::intValue)); //通过summarizingInt同时求总和、平均值、最大值、最小值 ints.stream().collect(Collectors.summarizingInt(Integer::intValue));
Stream 终端操作（collect）
List<Integer> ints = Arrays.asList(1, 1, 2, 2, 3); //返回List ints.stream().collect(Collectors.toList()); //返回Set ints.stream().collect(Collectors.toSet()); //返回Map ints.stream().collect(Collectors.toMap(k -> k, v -> v, (v1, v2) -> v1)); //group分组 ints.stream().collect(Collectors.groupingBy(k -> k)); //partitioningBy分区 ints.stream().collect(Collectors.partitioningBy(k -> k % 2 == 0));