快速掌握Java8 Stream函数式编程技巧

函数式编程优势

“函数第一位”，即函数可以出现在任何地方。
可以把函数作为参数传递给另一个函数，还可以将函数作为返回值。
让代码的逻辑更清晰更优雅。
减少了可变量(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类库做了升级优化，代码不用做任何修改就能享受到升级带来的好处。

参考 Java 8 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));

Stream参考文献