JDK新特性（五）——Stream流
前言
Stream流的概念是在JDK1.8的时候提出来的，是对集合(Collection)对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作，或者大批量数据操作。通常我们需要多行代码才能完成的操作，借助于Stream流式处理可以很简单的实现。本文将对Stream流的工作流程和常用的api进行讲解，希望对各位读者有所帮助。
提示：如果你对Lambda表达式、函数式接口和方法引用等概念没有了解，建议先去阅读本系列文章中这部分的内容，再来阅读本文：
JDK新特性（一）——Lambda表达式
JDK新特性（三）——方法引用
JDK新特性（四）——函数式接口
一、Stream流的初使用
我们在前言中讲到，Stream流可以实现对集合对象处理步骤的简化和大批量数据的操作，相比于本系列其他文章而言，Stream流可能是我们工作中相对来说使用和接触得更多的特性了。
下面我们不妨来看一个例子，体验一下Stream流的强大之处：
要求我们定义一个方法，把字符串数组中以张开头，字符串长度大于2的字符进行输出。
public class StreamTest {
public static void main(String[] args) {
String[] arr = {"张三丰","张超","章口就来","张口就来"};
filterStrMethod(arr);
}
private static void filterStrMethod(String[] arr){
List<String> nameList = new ArrayList<>();
List<String> lengthList = new ArrayList<>();
for (int i = 0; i < arr.length; i++) {
if(arr[i].startsWith("张")){
nameList.add(arr[i]);
}
}
for (int i = 0; i < nameList.size(); i++) {
if(nameList.get(i).length()>2){
lengthList.add(nameList.get(i));
}
}
System.out.println(lengthList);
}
}
（上面这个方法自然可以只用一个for循环解决，目的主要是出于模拟过滤两次的效果）
我们可以看到，使用常规的for循环虽然可以解决问题，但相对来说代码量不少。我们再来看看使用Stream流可以怎么样来优化解决的方案：
public class StreamTest {
public static void main(String[] args) {
String[] arr = {"张三丰","张超","章口就来","张口就来"};
filterStrByStream(arr);
}
private static void filterStrByStream(String[] arr){
Stream.of(arr).filter(s -> s.startsWith("张")).filter(s -> s.length()>2).forEach(System.out::println);
}
}
我们可以看到，使用Stram流的方式后，原先的需求我们只用了一行代码就实现了！！！
这就是Stream流的强大之处，让我们的代码更简洁，更简单直接。Stream流把真正的函数式编程风格引入到Java中
二、Stream流的生成方式
我们对流的操作一般来说会从三个阶段进行，分别是流的生成、流的中间操作和流的终结操作方法。我们将源数据转换成流对象后，可以对其进行过滤、排序、元素跳跃和元素限制等操作，最终再使用例如foreach的方法对流进行结束。
三、Stream流操作篇
（一）Stream流的生成方式
Stream流支持多种渠道的数据源转为流对象，下面将主要进行Collection等集合类的流生成方式
Collection体系集合
使用默认方法stream()生成流， default Stream stream()
Map体系集合
把Map转成Set集合，间接的生成流
数组
通过Stream接口的静态方法of(T... values)生成流
下面我们来用代码演示一下流的生成
public class StreamCreateDemo {
public static void main(String[] args) {
streamCreateTest();
}
private static void streamCreateTest(){
// List集合转Stream流
List<String> list = new ArrayList<>();
Stream<String> listStream = list.stream();
// Set集合转Stream流
Set<Integer> set = new HashSet<>();
Stream<Integer> setStream = set.stream();
// Map集合间接转Stream流
Map<String,Integer> map = new HashMap<>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
// 数组转Stream流，使用 Stream接口中的静态方法 of(T ...values)
String[] arr = new String[5];
Stream<String> arrStream1 = Stream.of(arr);
Stream<String> arrStream2 = Stream.of("10","20","13");
}
}
（二）Stream流的中间操作方法
中间操作的意思是，执行完此方法之后，Stream流依然可以继续执行其他操作.
| 方法名 | 说明 |
|---|---|
| Stream filter(Predicate predicate) | 用于对流中的数据进行过滤 |
| Stream limit(long maxSize) | 返回此流中的元素组成的流，截取前指定参数个数的数据 |
| Stream skip(long n) | 跳过指定参数个数的数据，返回由该流的剩余元素组成的流 |
| static Stream concat(Stream a, Stream b) | 合并a和b两个流为一个流 |
| Stream distinct() | 返回由该流的不同元素（根据Object.equals(Object))组成的流 |
| Stream sorted() | 返回由此流的元素组成的流，根据自然顺序排序 |
| Stream sorted(Comparator comparator) | 返回由该流的元素组成的流，根据提供的Comparator进行排序 |
| Stream map(Function mapper) | 返回由给定函数应用于此流的元素的结果组成的流 |
| lntStream mapTolnt(TolntFunction mapper) | 返回一个Intstream其中包含将给定函数应用于此流的元素的结果 |
下面我们就来演示一下吧
filter方法
要求过滤出Stream流中以胡开头，字符长度大于2的元素
public class StreamCreateDemo {
public static void main(String[] args) {
List list = Arrays.asList("胡宗宪","胡萝卜","胡说","大胡子");
filterTest(list);
}
private static void filterTest(List<String> list){
list.stream().filter(s->s.startsWith("胡")&&s.length()>2).forEach(System.out::println);
}
}
limit和skip方法
要求跳过Stream流中中前两个元素，只取接下来后面的两个元素
public class StreamCreateDemo {
public static void main(String[] args) {
List list = Arrays.asList("胡宗宪","刘亦菲","流光溢彩","胡萝卜","胡说","大胡子");
skipAndLimitTest(list);
}
private static void skipAndLimitTest(List<String> list){
list.stream().skip(2).limit(2).forEach(s -> System.out.println(s));
}
}
concat和distinct方法
要求将两个流进行合并，然后去重后进行打印输出
public class StreamCreateDemo {
public static void main(String[] args) {
List list1 = Arrays.asList(10,20,30,40);
List list2 = Arrays.asList(30,40,50,60);
concatAndDistinctTest(list1,list2);
}
private static void concatAndDistinctTest(List<Integer> list1,List<Integer> list2){
Stream listStream1 = list1.stream();
Stream listStream2 = list2.stream();
Stream.concat(listStream1,listStream2).distinct().forEach(System.out::println);
}
}
sort方法
要求：将Stream流中的元素根据字符长度进行（正序）排序，如果长度相等，则按照字母大小排序。
public class StreamCreateDemo {
public static void main(String[] args) {
List list1 = Arrays.asList("张国荣","刘翔","黄志明","于谦");
sortTest(list1);
}
private static void sortTest(List<String> list){
// comparingInt表示将比较括号内的两个元素的字符长度
list.stream().sorted(Comparator.comparingInt(String::length).thenComparing((s1,s2) -> (s1.compareTo(s2)>0?-1:1))).forEach(System.out::println);
}
map和mapToInt方法
map和mapInt方法和上面的其他方法略有不同，因为其他方法只是对流中的元素进行过滤、排序等操作，并不会真正改动到流中的元素内容，而map就可以实现改变流中元素
要求将Stream流中的字符串元素转为整形元素进行打印输出
public class StreamCreateDemo {
public static void main(String[] args) {
List list1 = Arrays.asList("124","13","134","163");
mapTest(list1);
}
private static void mapTest(List<String> list){
list.stream().map(Integer::parseInt).forEach(System.out::println);
}
}
要求将Stream流中的字符串元素转为整形元素后进行求和操作
public class StreamCreateDemo {
public static void main(String[] args) {
List list1 = Arrays.asList("124","13","134","163");
mapIntTest(list1);
}
private static void mapIntTest(List<String> list){
System.out.println(list.stream().mapToInt(Integer::parseInt).sum());
}
}
（三）Stream流的终止操作
终结操作的意思是，执行完此方法之后，Stream流将不能再执行其他操作。
常用方法
| 方法名 | 说明 |
|---|---|
| void forEach(Consumer action) | 对此流的每个元素执行操作 |
| long count() | 返回此流中的元素数 |
下面就用一个小案例来演示一下吧
public class StreamCreateDemo {
public static void main(String[] args) {
List list1 = Arrays.asList("韦小宝","郑成功","王多鱼","刘翔");
countTest(list1);
}
private static void countTest(List<String> list){
long count = list.stream().filter(s -> s.length() > 2).count();
System.out.println(count);
}
}
四、Stream流的收集操作
流的收集操作是指：我们对数据使用Stream流的方式操作完毕后，可以把流中的数据收集到集合中。
常用方法
| 方法名 | 说明 |
|---|---|
| R collect(Collector collector) | 把结果收集到集合中 |
我们可以看到，collect方法需要我们传递一个Collector对象，但Collector是一个接口，所以我们一般会借助工具类Collectors来帮助我们实现收集的动作。
工具类Collectors提供了具体的收集方式
| 方法名 | 说明 |
|---|---|
| public static Collector toList() | 把元素收集到List集合中 |
| public static collector toSet() | 把元素收集到set集合中 |
| public static Collector toMap(Function keyMapper,Function valueMapper) | 把元素收集到Map集合中 |
下面我们就用一个小案例来演示一下如何使用Stream流的收集操作吧
public class StreamCreateDemo {
public static void main(String[] args) {
List list1 = Arrays.asList("韦小宝","郑成功","王多鱼","刘翔","韦小宝");
List list2 = Arrays.asList("韦小宝,12","郑成功,41","王多鱼,12","刘翔,45","大宝,41");
collectToSet(list1);
collectToList(list1);
collectToMap(list2);
}
private static void collectToSet(List<String> list){
Set<String> set = list.stream().filter(s -> s.length() > 2).collect(Collectors.toSet());
System.out.println(set);
}
private static void collectToList(List<String> list){
List<String> result = list.stream().filter(s -> s.length() > 2).collect(Collectors.toList());
System.out.println(result);
}
private static void collectToMap(List<String> list){
Map<String,Integer> map = list.stream().filter(s -> s.length() > 2).collect(Collectors.toMap(s -> s.split(",")[0],s -> Integer.parseInt(s.split(",")[1])));
for(String key : map.keySet()){
Integer num = map.get(key);
System.out.println(key + " : " + num);
}
}
}
五、注意事项
1. 流不能被重复使用，流关闭后也不能再被使用
2. 流的每个中间操作都会返回一个全新的流对象，直到遇到及早求值（终止操作）才会执行得到最终结果，如果没有终止操作，则所有中间操作根本不会执行。
至此有关Stream流的介绍就到这里了，Stream流的使用可以在一定程度上减少减少我们在工作中的代码开发量，学习的成本相当来说也不高，个人觉得Stream流的应用属于java开发人员应该要掌握的知识点之一。
参考文章：
Stream流介绍及实例:
https://www.jianshu.com/p/43f853c3c5d3
