一文带你入门Java Stream流，太强了
两个星期以前，就有读者强烈要求我写一篇 java stream 流的文章，我说市面上不是已经有很多了吗，结果你猜他怎么说：“就想看你写的啊！”你看你看，多么苍白的喜欢啊。那就“勉为其难”写一篇吧，嘻嘻。
单从“stream”这个单词上来看，它似乎和 java.io 包下的 inputstream 和 outputstream 有些关系。实际上呢，没毛关系。java 8 新增的 stream 是为了解放程序员操作集合（collection）时的生产力，之所以能解放，很大一部分原因可以归功于同时出现的 lambda 表达式——极大的提高了编程效率和程序可读性。
stream 究竟是什么呢？
stream 就好像一个高级的迭代器，但只能遍历一次，就好像一江春水向东流；在流的过程中，对流中的元素执行一些操作，比如“过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等。
要想操作流，首先需要有一个数据源，可以是数组或者集合。每次操作都会返回一个新的流对象，方便进行链式操作，但原有的流对象会保持不变。
流的操作可以分为两种类型：
1）中间操作，可以有多个，每次返回一个新的流，可进行链式操作。
2）终端操作，只能有一个，每次执行完，这个流也就用光光了，无法执行下一个操作，因此只能放在最后。
来举个例子。
list<string> list = new arraylist<>();
list.add("武汉加油");
list.add("中国加油");
list.add("世界加油");
list.add("世界加油");
long count = list.stream().distinct().count();
system.out.println(count);
distinct() 方法是一个中间操作（去重），它会返回一个新的流（没有共同元素）。
stream<t> distinct();
count() 方法是一个终端操作，返回流中的元素个数。
long count();
中间操作不会立即执行，只有等到终端操作的时候，流才开始真正地遍历，用于映射、过滤等。通俗点说，就是一次遍历执行多个操作，性能就大大提高了。
理论部分就扯这么多，下面直接进入实战部分。
01、创建流
如果是数组的话，可以使用 arrays.stream() 或者 stream.of() 创建流；如果是集合的话，可以直接使用 stream() 方法创建流，因为该方法已经添加到 collection 接口中。
public class createstreamdemo {
public static void main(string[] args) {
string[] arr = new string[]{"武汉加油", "中国加油", "世界加油"};
stream<string> stream = arrays.stream(arr);
stream = stream.of("武汉加油", "中国加油", "世界加油");
list<string> list = new arraylist<>();
list.add("武汉加油");
list.add("中国加油");
list.add("世界加油");
stream = list.stream();
}
}
查看 stream 源码的话，你会发现 of() 方法内部其实调用了 arrays.stream() 方法。
public static<t> stream<t> of(t... values) {
return arrays.stream(values);
}
另外，集合还可以调用 parallelstream() 方法创建并发流，默认使用的是 forkjoinpool.commonpool()线程池。
list<long> alist = new arraylist<>();
stream<long> parallelstream = alist.parallelstream();
02、操作流
stream 类提供了很多有用的操作流的方法，我来挑一些常用的给你介绍一下。
1）过滤
通过 filter() 方法可以从流中筛选出我们想要的元素。
public class filterstreamdemo {
public static void main(string[] args) {
list<string> list = new arraylist<>();
list.add("周杰伦");
list.add("王力宏");
list.add("陶喆");
list.add("林俊杰");
stream<string> stream = list.stream().filter(element -> element.contains("王"));
stream.foreach(system.out::println);
}
}
filter() 方法接收的是一个 predicate（java 8 新增的一个函数式接口，接受一个输入参数返回一个布尔值结果）类型的参数，因此，我们可以直接将一个 lambda 表达式传递给该方法，比如说 element -> element.contains("王") 就是筛选出带有“王”的字符串。
foreach() 方法接收的是一个 consumer（java 8 新增的一个函数式接口，接受一个输入参数并且无返回的操作）类型的参数，类名 :: 方法名是 java 8 引入的新语法，system.out 返回 printstream 类，println 方法你应该知道是打印的。
stream.foreach(system.out::println); 相当于在 for 循环中打印，类似于下面的代码：
for (string s : strs) {
system.out.println(s);
}
很明显，一行代码看起来更简洁一些。来看一下程序的输出结果：
王力宏
2）映射
如果想通过某种操作把一个流中的元素转化成新的流中的元素，可以使用 map() 方法。
public class mapstreamdemo {
public static void main(string[] args) {
list<string> list = new arraylist<>();
list.add("周杰伦");
list.add("王力宏");
list.add("陶喆");
list.add("林俊杰");
stream<integer> stream = list.stream().map(string::length);
stream.foreach(system.out::println);
}
}
map() 方法接收的是一个 function（java 8 新增的一个函数式接口，接受一个输入参数 t，返回一个结果 r）类型的参数，此时参数 为 string 类的 length 方法，也就是把 stream<string> 的流转成一个 stream<integer> 的流。
程序输出的结果如下所示：
3
3
2
3
3）匹配
stream 类提供了三个方法可供进行元素匹配，它们分别是：
anymatch()，只要有一个元素匹配传入的条件，就返回 true。allmatch()，只有有一个元素不匹配传入的条件，就返回 false；如果全部匹配，则返回 true。nonematch()，只要有一个元素匹配传入的条件，就返回 false；如果全部匹配，则返回 true。
public class matchstreamdemo {
public static void main(string[] args) {
list<string> list = new arraylist<>();
list.add("周杰伦");
list.add("王力宏");
list.add("陶喆");
list.add("林俊杰");
boolean anymatchflag = list.stream().anymatch(element -> element.contains("王"));
boolean allmatchflag = list.stream().allmatch(element -> element.length() > 1);
boolean nonematchflag = list.stream().nonematch(element -> element.endswith("沉"));
system.out.println(anymatchflag);
system.out.println(allmatchflag);
system.out.println(nonematchflag);
}
}
因为“王力宏”以“王”字开头，所以 anymatchflag 应该为 true；因为“周杰伦”、“王力宏”、“陶喆”、“林俊杰”的字符串长度都大于 1，所以 allmatchflag 为 true；因为 4 个字符串结尾都不是“沉”，所以 nonematchflag 为 true。
程序输出的结果如下所示：
true
true
true
4）组合
reduce() 方法的主要作用是把 stream 中的元素组合起来，它有两种用法：
optionalreduce(binaryoperator accumulator)
没有起始值，只有一个参数，就是运算规则，此时返回 optional。
t reduce(t identity, binaryoperatoraccumulator)
有起始值，有运算规则，两个参数，此时返回的类型和起始值类型一致。
来看下面这个例子。
public class reducestreamdemo {
public static void main(string[] args) {
integer[] ints = {0, 1, 2, 3};
list<integer> list = arrays.aslist(ints);
optional<integer> optional = list.stream().reduce((a, b) -> a + b);
optional<integer> optional1 = list.stream().reduce(integer::sum);
system.out.println(optional.orelse(0));
system.out.println(optional1.orelse(0));
int reduce = list.stream().reduce(6, (a, b) -> a + b);
system.out.println(reduce);
int reduce1 = list.stream().reduce(6, integer::sum);
system.out.println(reduce1);
}
}
运算规则可以是 lambda 表达式（比如 (a, b) -> a + b），也可以是类名::方法名（比如 integer::sum）。
程序运行的结果如下所示：
6
6
12
12
0、1、2、3 在没有起始值相加的时候结果为 6；有起始值 6 的时候结果为 12。
03、转换流
既然可以把集合或者数组转成流，那么也应该有对应的方法，将流转换回去——collect() 方法就满足了这种需求。
public class collectstreamdemo {
public static void main(string[] args) {
list<string> list = new arraylist<>();
list.add("周杰伦");
list.add("王力宏");
list.add("陶喆");
list.add("林俊杰");
string[] strarray = list.stream().toarray(string[]::new);
system.out.println(arrays.tostring(strarray));
list<integer> list1 = list.stream().map(string::length).collect(collectors.tolist());
list<string> list2 = list.stream().collect(collectors.tocollection(arraylist::new));
system.out.println(list1);
system.out.println(list2);
string str = list.stream().collect(collectors.joining(", ")).tostring();
system.out.println(str);
}
}
toarray() 方法可以将流转换成数组，你可能比较好奇的是 string[]::new，它是什么东东呢？来看一下 toarray() 方法的源码。
<a> a[] toarray(intfunction<a[]> generator);
也就是说 string[]::new 是一个 intfunction，一个可以产生所需的新数组的函数，可以通过反编译字节码看看它到底是什么：
string[] strarray = (string[])list.stream().toarray((x$0) -> {
return new string[x$0];
});
system.out.println(arrays.tostring(strarray));
也就是相当于返回了一个指定长度的字符串数组。
当我们需要把一个集合按照某种规则转成另外一个集合的时候，就可以配套使用 map() 方法和 collect() 方法。
list<integer> list1 = list.stream().map(string::length).collect(collectors.tolist());
通过 stream() 方法创建集合的流后，再通过 map(string:length) 将其映射为字符串长度的一个新流，最后通过 collect() 方法将其转换成新的集合。
collectors 是一个收集器的工具类，内置了一系列收集器实现，比如说 tolist() 方法将元素收集到一个新的 java.util.list 中；比如说 tocollection() 方法将元素收集到一个新的 java.util.arraylist 中；比如说 joining() 方法将元素收集到一个可以用分隔符指定的字符串中。
来看一下程序的输出结果：
[周杰伦, 王力宏, 陶喆, 林俊杰]
[3, 3, 2, 3]
[周杰伦, 王力宏, 陶喆, 林俊杰]
周杰伦, 王力宏, 陶喆, 林俊杰
04、鸣谢
好了，我亲爱的读者朋友，以上就是本文的全部内容了，是不是感觉 stream 流实在是太强大了？我是沉默王二，一枚有趣的程序员。原创不易，莫要白票，请你为本文点赞个吧，这将是我写作更多优质文章的最强动力。
如果觉得文章对你有点帮助，请微信搜索「 沉默王二 」第一时间阅读，回复【666】更有我为你精心准备的 500g 高清教学视频（已分门别类）。本文 github 已经收录，有大厂面试完整考点，欢迎 star。