一、概述
Java 8之所以费这么大功夫引入函数式编程，原因原因有如下两点：
-
代码简洁：函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。
-
多核友好：Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是调用一下
parallel()方法。
对于Java 7来说stream完全是个陌生东西，stream并不是某种数据结构，它只是数据源的一种视图。这里的数据源可以是一个数组，容器或I/O channel等。正因如此要得到一个stream通常不会手动创建，而是调用对应的工具方法，比如：
- 调用
Collection.stream()或者Collection.parallelStream()方法； - 调用
Arrays.stream(T[] array)方法；
常见的stream接口继承关系如图：
图中4种stream接口继承自BaseStream，其中IntStream, LongStream, DoubleStream对应三种基本类型（int, long, double，注意不是包装类型），Stream对应所有剩余类型的stream视图。为不同数据类型设置不同的stream接口，有两种好处：提高性能和增加特定接口函数。
虽然大部分情况下stream是容器调用Collection.stream()方法得到的，但stream和collections有以下不同：
- 无存储：stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。
- 为函数式编程而生：对stream的任何修改都不会修改背后的数据源，如对stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新stream。
- 惰式执行：stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。
- 可消费性：stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。
对stream的操作分为为两类，中间操作(intermediate operations)和结束操作(terminal operations)，二者特点是：
- 中间操作总是会惰式执行，调用中间操作只会生成一个标记了该操作的新stream，仅此而已。
- 结束操作会触发实际计算，计算发生时会把所有中间操作积攒的操作以管道pipeline的方式执行，这样可以减少迭代次数。计算完成之后stream就会失效。
下表汇总了Stream接口的部分常见方法：
| 操作类型 | 接口方法 |
|---|---|
| 中间操作 | concat()、distinct()、 filter()、 flatMap()、 limit()、 map() 、peek() 、skip() 、sorted()、 parallel()、 sequential()、 unordered() |
| 结束操作 | allMatch() 、anyMatch()、 collect() 、count() 、findAny()、 findFirst()、 forEach() 、forEachOrdered()、 max() 、min()、 noneMatch()、 reduce()、 toArray() |
区分中间操作和结束操作最简单的方法，就是看方法的返回值，返回值为stream的大都是中间操作，否则是结束操作。
二、Stream方法使用
stream跟函数接口关系非常紧密，没有函数接口stream就无法工作。回顾一下：函数接口是指内部有抽象方法的接口。通常函数接口出现的地方都可以使用Lambda表达式，所以不必记忆函数接口的名字。
（1）forEach()
我们对forEach()方法并不陌生，在Collection中我们已经见过。方法签名为void forEach(Consumer<? super E> action)，作用是对容器中的每个元素执行action指定的动作，也就是对元素进行遍历。
List<String> list = new ArrayList<>();
list.add("start");
list.add("learn");
list.add("stream");
// 常规遍历出list中长度大于5的元素
list.forEach(s -> {
if (s.length() > 5) {
System.out.println("使用lambda和stream遍历list：" + s);
}
});
// 使用stream流的filter()方法进行过滤，然后在进行遍历输出
list.stream().filter(s -> s.length() > 5).forEach(s -> System.out.println("流：" + s));
// 使用Stream.forEach()迭代
Stream<String> stream = Stream.of("I", "love", "liangliang");
stream.forEach(str -> System.out.println("使用流的循环遍历方法：" + str));
（2）filter()
函数原型为Stream<T> filter(Predicate<? super T> predicate)，作用是返回一个只包含满足predicate条件元素的Stream。
操作如（1）所示，但是使用filter()方式时需要注意，由于filter()是个中间操作，如果只调用filter()不会有实际计算，因此也不会输出任何信息。
（3）distinct()
函数原型为Stream<T> distinct()，作用是返回一个去除重复元素之后的Stream。如下代码所示：
List<String> list = new ArrayList<>();
list.add("start");
list.add("learn");
list.add("stream");
list.add("stream");
// 去掉重复的元素 distinct()方法是一个中间操作，会将去重后的元素重新生成一个stream
list.stream().distinct().forEach(s -> System.out.println("去重之后的元素：" + s));
（4）sorted()
排序函数有两个，一个是用自然顺序排序，一个是使用自定义比较器排序，函数原型分别为Stream<T> sorted()和Stream<T> sorted(Comparator<? super T> comparator)。代码如下所示：
List<String> list = new ArrayList<>();
list.add("start");
list.add("len");
list.add("stream");
list.add("streaom");
list.stream().sorted(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
// 默认升序排序
return o1.length() - o2.length();
}
}).forEach(s -> System.out.println("长度升序排序输出：" + s));
// 当采用默认升序排序时，可以采用如下引用的写法
list.stream().sorted(Comparator.comparingInt(String::length)).forEach(s -> System.out.println("长度升序排序输出：" + s));
// 使用流的sorted()方法按照元素长度降序排序，然后输出
list.stream().sorted((o1, o2) -> {
return o2.length() - o1.length();
}).forEach(s -> System.out.println("长度降序排序输出：" + s));
（5）map()
函数原型为<R> Stream<R> map(Function<? super T,? extends R> mapper)，作用是返回一个对当前所有元素执行执行mapper之后的结果组成的Stream。直观的说，就是对每个元素按照某种操作进行转换，转换前后Stream中元素的个数不会改变，但元素的类型取决于转换之后的类型。
如下代码所示：
List<String> list = new ArrayList<>();
list.add("start");
list.add("len");
list.add("stream");
list.add("streaom");
list.stream().map(new Function<String, Object>() {
@Override
public Object apply(String s) {
if (s.length() > 5) {
return s.toUpperCase();
} else {
return s;
}
}
}).forEach(s -> System.out.println("转换后的元素:" + s));
// lambda写法
list.stream().map(s -> {
if (s.length() > 6) {
return s.toUpperCase();
} else {
return s;
}
}).forEach(s -> System.out.println("转换后的元素:" + s));
（6）flatMap()
函数原型为<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)，作用是对每个元素执行mapper指定的操作，并用所有mapper返回的Stream中的元素组成一个新的Stream作为最终返回结果。说起来太拗口，通俗的讲flatMap()的作用就相当于把原stream中的所有元素都”摊平”之后组成的Stream，转换前后元素的个数和类型都可能会改变。代码如下：
List<String> list = new ArrayList<>();
list.add("start");
list.add("len");
list.add("stream");
list.add("streaom");
List<String> newList = new ArrayList<>();
newList.add("start");
newList.add("len");
newList.add("stream");
newList.add("streaom");
// 构建一个stream流
Stream<List<String>> stream = Stream.of(list, newList);
// 会把这两个list合并成一个list
stream.flatMap(l -> l.stream()).forEach(i -> System.out.print(i + " "));
// 引用的写法，效果同上
stream.flatMap(Collection::stream).forEach(i -> System.out.print(i + " "));
参考博文：
（1）https://objcoding.com/2019/03/04/lambda/ （非常详细，值得仔细阅读）
（2）https://www.runoob.com/java/java8-lambda-expressions.html