JDK新特性——Stream代码简洁之道

也想出现在这里？点击联系我~

一、概述

Stream 是一组用来处理数组、集合的API，Stream API 提供了一种高效且易于使用的处理数据的方式。Java 8 中之所以费这么大的功夫引入 函数式编程 ，原因有两个：

代码简洁函数式编程写出的代码简洁且意图明确，使用stream接口让你从此告别for循环。

多核友好，Java函数式编程使得编写并行程序从未如此简单，你需要的全部就是用用一下parallel()方法

Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作

二、Stream特性

1、不是数据结构，没有内部存储，不会保存数据，故每个Stream流只能使用一次 2、不支持索引访问 3、支持并行 4、很容易生成数据或集合(List，Set) 5、支持过滤、查找、转换、汇总、聚合等操作 6、延迟计算，流在中间处理过程中，只是对操作进行了记录，并不会立即执行，需要等到执行终止操作的时候才会进行实际的计算

三、分类

关于应用在Stream流上的操作，可以分成两种：

1. Intermediate(中间操作)： 中间操作的返回结果都是Stream，故可以多个中间操作叠加;
2. Terminal(终止操作)： 终止操作用于返回我们最终需要的数据，只能有一个终止操作。

使用Stream流，可以清楚地知道我们要对一个数据集做何种操作，可读性强。而且可以很轻松地获取并行化Stream流，不用自己编写多线程代码，可以让我们更加专注于业务逻辑。

无状态： 指元素的处理不受之前元素的影响;有状态： 指该操作只有拿到所有元素之后才能继续下去。非短路操作： 指必须处理所有元素才能得到最终结果;短路操作： 指遇到某些符合条件的元素就可以得到最终结果，如 A || B，只要A为true，则无需判断B的结果。

四、Stream的创建

1、通过数组来生成 2、通过集合来生成 3、通过Stream.generate方法来创建 4、通过Stream.iterate方法来创建 5、其他Api创建

4.1 通过数组来生成

1. //通过数组来生成
2. staticvoidgen1(){
3. String[]strs={"a","b","c","d"};
4. Stream<String>strs1=Stream.of(strs);//使用Stream中的静态方法：of()
5. strs1.forEach(System.out::println);//打印输出(a、b、c、d)
6. }

4.2 通过集合来生成

1. //通过集合来生成
2. staticvoidgen2(){
3. List<String>list=Arrays.asList("1","2","3","4");
4. Stream<String>stream=list.stream();//获取一个顺序流
5. stream.forEach(System.out::println);//打印输出（1,2,3,4）
6. }

4.3 通过Stream.generate方法来创建

1. //generate
2. staticvoidgen3(){
3. Stream<Integer>generate=Stream.generate(()->1);//使用Stream中的静态方法：generate()
4. //limit返回由该流的元素组成的流，截断长度不能超过maxSize
5. generate.limit(10).forEach(System.out::println);//打印输出(打印10个1)
6. }

4.4 通过Stream.iterate方法来创建

1. //使用iterator
2. staticvoidgen4(){
3. Stream<Integer>iterate=Stream.iterate(1,x->x+1);//使用Stream中的静态方法：iterate()
4. iterate.limit(10).forEach(System.out::println);//打印输出(1,2,3,4,5,6,7,8,9,10)
5. }

4.5其他Api创建

1. //其他方式
2. staticvoidgen5(){
3. Stringstr="abcdefg";
4. IntStreamstream=str.chars();//获取str字节码
5. stream.forEach(System.out::println);//打印输出(97,98,99,100,101,102,103)
6. }

五、Stream的常用API

5.1 中间操作

1. filter：过滤流中的某些元素

1. //中间操作:如果调用方法之后返回的结果是Stream对象就意味着是一个中间操作
2. Arrays.asList(1,2,3,4,5).stream()//获取顺序流
3. .filter((x)->x%2==0)//24
4. .forEach(System.out::println);
6. //求出结果集中所有偶数的和
7. intcount=Arrays.asList(1,2,3,4,5,6,7,8,9).stream()//获取顺序流
8. .filter(x->x%2==0).//2468
9. mapToInt(x->x).sum();//求和
10. System.out.println(count);//打印输出20

2. distinct：通过流中元素的 hashCode() 和 equals() 去除重复元素

1. Arrays.asList(1,2,3,3,3,4,5,2).stream()//获取顺序流
2. .distinct()//去重
3. .forEach(System.out::println);//打印输出(1,2,3,4,5)
5. System.out.println("去重：—————");
7. Arrays.asList(1,2,3,3,3,4,5,2).stream()//获取顺序流
8. .collect(Collectors.toSet())//Set()去重
9. .forEach(System.out::println);//打印输出(1,2,3,4,5)

3. 排序

sorted()：返回由此流的元素组成的流，根据自然顺序排序。sorted(Comparator com)：返回由该流的元素组成的流，根据提供的 Comparator进行排序。

1. //获取最大值和最小值但是不使用min和max方法
2. List<Integer>list=Arrays.asList(1,2,3,4,5,6);
3. Optional<Integer>min=list.stream().sorted().findFirst();//自然排序根据数字从小到大排列
4. System.out.println(min.get());//打印输出（1）
6. Optional<Integer>max2=list.stream().sorted((a,b)->b-a).findFirst();//定时排序根据最大数进行排序
7. System.out.println(max2.get());//打印输出（6）
9. //按照大小(a-z)排序
10. Arrays.asList("java","c#","python","scala").stream().sorted().forEach(System.out::println);
11. //按照长度排序
12. Arrays.asList("java","c#","python","scala").stream().sorted((a,b)->a.length()-b.length()).forEach(System.out::println);

4. 截取

limit(n)：返回由此流的元素组成的流，截短长度不能超过 nskip(n)：在丢弃流的第n元素后，配合limit(n)可实现分页

1. //打印20-30这样的集合数据
2. Stream.iterate(1,x->x+1).limit(50)//limit50总共到50
3. .skip(20)//跳过前20
4. .limit(10)//打印10个
5. .forEach(System.out::println);//打印输出(21,22,23,24,25,26,27,28,29,30)

5. 转换

map：接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。flatMap：接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。

1. List<String>list=Arrays.asList("a,b,c","1,2,3");
3. //将每个元素转成一个新的且不带逗号的元素
4. Stream<String>s1=list.stream().map(s->s.replaceAll(",",""));
5. s1.forEach(System.out::println);//abc123
7. Stream<String>s3=list.stream().flatMap(s->{
8. //将每个元素转换成一个stream
9. String[]split=s.split(",");
10. Stream<String>s2=Arrays.stream(split);
11. returns2;
12. });
13. s3.forEach(System.out::println);//abc123

6. 消费

peek：如同于map，能得到流中的每一个元素。但map接收的是一个Function表达式，有返回值;而peek接收的是Consumer表达式，没有返回值。

1. //将str中的每一个数值都打印出来，同时算出最终的求和结果
2. Stringstr="11,22,33,44,55";
3. System.out.println(Stream.of(str.split(",")).peek(System.out::println).mapToInt(Integer::valueOf).sum());//1122334455165

5.2 终止操作

1. 循环：forEach

Users类：

1. importjava.util.Date;
3. /**
4. *@program:lambda
5. *@ClassNameUsers
6. *@description:
7. *@author:muxiaonong
8. *@create:2020-10-2411:00
9. *@Version1.0
10. **/
11. publicclassUsers{
13. privateStringname;
14. publicUsers(){}
16. /**
17. *@paramname
18. */
19. publicUsers(Stringname){
20. this.name=name;
21. }
23. /**
24. *@paramname
25. *@return
26. */
27. publicstaticUsersbuild(Stringname){
28. Usersu=newUsers();
29. u.setName(name);
30. returnu;
31. }
33. publicStringgetName(){
34. returnname;
35. }
37. publicvoidsetName(Stringname){
38. this.name=name;
39. }
41. @Override
42. publicStringtoString(){
43. return"name='"+name+'\\'';
44. }
45. }

1. //创建一组自定义对象
2. Stringstr2="java,scala,python";
3. Stream.of(str2.split(",")).map(x->newUsers(x)).forEach(System.out::println);//打印输出（name='java'name='scala'name='python'）
4. Stream.of(str2.split(",")).map(Users::new).forEach(System.out::println);//打印输出（name='java'name='scala'name='python'）
5. Stream.of(str2.split(",")).map(x->Users.build(x)).forEach(System.out::println);//打印输出（name='java'name='scala'name='python'）
6. Stream.of(str2.split(",")).map(Users::build).forEach(System.out::println);//打印输出（name='java'name='scala'name='python'）

2. 计算：min、max、count、sum

min：返回流中元素最小值max：返回流中元素最大值count：返回流中元素的总个数sum：求和

1. //求集合中的最大值
2. List<Integer>list=Arrays.asList(1,2,3,4,5,6);
3. Optional<Integer>max=list.stream().max((a,b)->a-b);
4. System.out.println(max.get());//6
5. //求集合的最小值
6. System.out.println(list.stream().min((a,b)->a-b).get());//1
7. //求集合的总个数
8. System.out.println(list.stream().count());//6
9. //求和
10. Stringstr="11,22,33,44,55";
11. System.out.println(Stream.of(str.split(",")).mapToInt(x->Integer.valueOf(x)).sum());
12. System.out.println(Stream.of(str.split(",")).mapToInt(Integer::valueOf).sum());
13. System.out.println(Stream.of(str.split(",")).map(x->Integer.valueOf(x)).mapToInt(x->x).sum());
14. System.out.println(Stream.of(str.split(",")).map(Integer::valueOf).mapToInt(x->x).sum());

3. 匹配：anyMatch、 allMatch、 noneMatch、 findFirst、 findAny

anyMatch：接收一个 Predicate 函数，只要流中有一个元素满足该断言则返回true，否则返回falseallMatch：接收一个 Predicate 函数，当流中每个元素都符合该断言时才返回true，否则返回falsenoneMatch：接收一个 Predicate 函数，当流中每个元素都不符合该断言时才返回true，否则返回falsefindFirst：返回流中第一个元素findAny：返回流中的任意元素

1. List<Integer>list=Arrays.asList(1,2,3,4,5,6);
2. System.out.println(list.stream().allMatch(x->x>=0));//如果集合中的元素大于等于0返回true
3. System.out.println(list.stream().noneMatch(x->x>5));//如果集合中的元素有大于5的元素。返回false
4. System.out.println(list.stream().anyMatch(x->x>4));//如果集合中有大于四4的元素，返回true
5. //取第一个偶数
6. Optional<Integer>first=list.stream().filter(x->x%10==6).findFirst();
7. System.out.println(first.get());//6
8. //任意取一个偶数
9. Optional<Integer>any=list.stream().filter(x->x%2==0).findAny();
10. System.out.println(any.get());//2

4.收集器：toArray、collect

collect：接收一个Collector实例，将流中元素收集成另外一个数据结构Collector

1. Supplier supplier();创建一个结果容器A
2. BiConsumer
3. BinaryOperator combiner();函数接口，该参数的作用跟上一个方法(reduce)中的combiner参数一样，将并行流中各个子进程的运行结果(accumulator函数操作后的容器A)进行合并。
4. Function
5. Set characteristics();返回一个不可变的Set集合，用来表明该Collector的特征

1. /**
2. *@program:lambda
3. *@ClassNameCustomer
4. *@description:
5. *@author:muxiaonong
6. *@create:2020-10-2411:36
7. *@Version1.0
8. **/
9. publicclassCustomer{
11. privateStringname;
13. privateIntegerage;
15. …getset忽略
16. }
17. publicstaticvoidmain(String[]args){
18. Customerc1=newCustomer("张三",10);
19. Customerc2=newCustomer("李四",20);
20. Customerc3=newCustomer("王五",10);
22. List<Customer>list=Arrays.asList(c1,c2,c3);
24. //转成list
25. List<Integer>ageList=list.stream().map(Customer::getAge).collect(Collectors.toList());
26. System.out.println("ageList："+ageList);//ageList：[10,20,10]
28. //转成set
29. Set<Integer>ageSet=list.stream().map(Customer::getAge).collect(Collectors.toSet());
30. System.out.println("ageSet："+ageSet);//ageSet：[20,10]
32. //转成map,注:key不能相同，否则报错
33. Map<String,Integer>CustomerMap=list.stream().collect(Collectors.toMap(Customer::getName,Customer::getAge));
34. System.out.println("CustomerMap："+CustomerMap);//CustomerMap：{李四=20,张三=10,王五=10}
36. //字符串分隔符连接
37. StringjoinName=list.stream().map(Customer::getName).collect(Collectors.joining(",","(",")"));
38. System.out.println("joinName："+joinName);//joinName：(张三,李四,王五)
40. //聚合操作
41. //1.学生总数
42. Longcount=list.stream().collect(Collectors.counting());
43. System.out.println("count："+count);//count：3
44. //2.最大年龄(最小的minBy同理)
45. IntegermaxAge=list.stream().map(Customer::getAge).collect(Collectors.maxBy(Integer::compare)).get();
46. System.out.println("maxAge："+maxAge);//maxAge：20
48. //3.所有人的年龄
49. IntegersumAge=list.stream().collect(Collectors.summingInt(Customer::getAge));
50. System.out.println("sumAge："+sumAge);//sumAge：40
52. //4.平均年龄
53. DoubleaverageAge=list.stream().collect(Collectors.averagingDouble(Customer::getAge));
54. System.out.println("averageAge："+averageAge);//averageAge：13.333333333333334
56. //分组
57. Map<Integer,List<Customer>>ageMap=list.stream().collect(Collectors.groupingBy(Customer::getAge));
58. System.out.println("ageMap："+ageMap);//ageMap：{20=[com.mashibing.stream.Customer@20ad9418],10=[com.mashibing.stream.Customer@31cefde0,com.mashibing.stream.Customer@439f5b3d]}
61. //分区
62. //分成两部分，一部分大于10岁，一部分小于等于10岁
63. Map<Boolean,List<Customer>>partMap=list.stream().collect(Collectors.partitioningBy(v->v.getAge()>10));
64. System.out.println("partMap："+partMap);
66. //规约
67. IntegerallAge=list.stream().map(Customer::getAge).collect(Collectors.reducing(Integer::sum)).get();
68. System.out.println("allAge："+allAge);//allAge：40
71. }

1. publicstaticvoidmain(String[]args){
2. Customerc1=newCustomer("张三",10);
3. Customerc2=newCustomer("李四",20);
4. Customerc3=newCustomer("王五",10);
6. List<Customer>list=Arrays.asList(c1,c2,c3);
8. //转成list
9. List<Integer>ageList=list.stream().map(Customer::getAge).collect(Collectors.toList());
10. System.out.println("ageList："+ageList);//ageList：[10,20,10]
12. //转成set
13. Set<Integer>ageSet=list.stream().map(Customer::getAge).collect(Collectors.toSet());
14. System.out.println("ageSet："+ageSet);//ageSet：[20,10]
16. //转成map,注:key不能相同，否则报错
17. Map<String,Integer>CustomerMap=list.stream().collect(Collectors.toMap(Customer::getName,Customer::getAge));
18. System.out.println("CustomerMap："+CustomerMap);//CustomerMap：{李四=20,张三=10,王五=10}
20. //字符串分隔符连接
21. StringjoinName=list.stream().map(Customer::getName).collect(Collectors.joining(",","(",")"));
22. System.out.println("joinName："+joinName);//joinName：(张三,李四,王五)
24. //聚合操作
25. //1.学生总数
26. Longcount=list.stream().collect(Collectors.counting());
27. System.out.println("count："+count);//count：3
28. //2.最大年龄(最小的minBy同理)
29. IntegermaxAge=list.stream().map(Customer::getAge).collect(Collectors.maxBy(Integer::compare)).get();
30. System.out.println("maxAge："+maxAge);//maxAge：20
32. //3.所有人的年龄
33. IntegersumAge=list.stream().collect(Collectors.summingInt(Customer::getAge));
34. System.out.println("sumAge："+sumAge);//sumAge：40
36. //4.平均年龄
37. DoubleaverageAge=list.stream().collect(Collectors.averagingDouble(Customer::getAge));
38. System.out.println("averageAge："+averageAge);//averageAge：13.333333333333334
40. //分组
41. Map<Integer,List<Customer>>ageMap=list.stream().collect(Collectors.groupingBy(Customer::getAge));
42. System.out.println("ageMap："+ageMap);//ageMap：{20=[com.mashibing.stream.Customer@20ad9418],10=[com.mashibing.stream.Customer@31cefde0,com.mashibing.stream.Customer@439f5b3d]}
45. //分区
46. //分成两部分，一部分大于10岁，一部分小于等于10岁
47. Map<Boolean,List<Customer>>partMap=list.stream().collect(Collectors.partitioningBy(v->v.getAge()>10));
48. System.out.println("partMap："+partMap);
50. //规约
51. IntegerallAge=list.stream().map(Customer::getAge).collect(Collectors.reducing(Integer::sum)).get();
52. System.out.println("allAge："+allAge);//allAge：40
55. }

六、Stream的方法摘要

七、总结

对于Java中新特性除了 Stream 还有lamaba表达式都是可以帮忙我们很好的去优化代码，使我们的代码简洁且意图明确，避免繁琐的重复性的操作，对于文中有兴趣的小伙伴可以操作起来，又不懂的小伙伴可以在下面进行留言，小农看到了会第一时间回复大家，谢谢，大家加油!

原文地址：https://mp.weixin.qq.com/s/LuV5QGSfP60EPWBTeY3SuQ