|
|
51CTO旗下网站
|
|
移动端
创建专栏

简洁方便的集合处理:Java 8 stream流

java 8已经发行好几年了,前段时间java 12也已经问世,但平时的工作中,很多项目的环境还停留在java1.7中。

作者:杨亨|2019-06-27 10:32

背景

java 8已经发行好几年了,前段时间java 12也已经问世,但平时的工作中,很多项目的环境还停留在java1.7中。而且java8的很多新特性都是革命性的,比如各种集合的优化、lambda表达式等,所以我们还是要去了解java8的魅力。

今天我们来学习java8的Stream,并不需要理论基础,直接可以上手去用。

我接触stream的原因,是我要搞一个用户收入消费的数据分析。起初的统计筛选分组都是打算用sql语言直接从mysql里得到结果来展现的。但在操作中我们发现这样频繁地访问数据库,性能会受到很大的影响,分析速度会很慢。所以我们希望能通过访问一次数据库就拿到所有数据,然后放到内存中去进行数据分析统计过滤。

接着,我看了stream的API,发现这就是我想要的。

一、Stream理解

在java中我们称Stream为『』,我们经常会用流去对集合进行一些流水线的操作。stream就像工厂一样,只需要把集合、命令还有一些参数灌输到流水线中去,就可以加工成得出想要的结果。这样的流水线能大大简洁代码,减少操作。

二、Stream流程

原集合 —> 流  —> 各种操作(过滤、分组、统计) —> 终端操作

Stream流的操作流程一般都是这样的,先将集合转为流,然后经过各种操作,比如过滤、筛选、分组、计算。***的终端操作,就是转化成我们想要的数据,这个数据的形式一般还是集合,有时也会按照需求输出count计数。下文会一一举例。

简洁方便的集合处理——Java 8 stream流

三、API功能举例

首先,定义一个用户对象,包含姓名、年龄、性别和籍贯四个成员变量:

  1. import lombok.AllArgsConstructor;  
  2. import lombok.Builder;  
  3. import lombok.Data;  
  4. import lombok.NoArgsConstructor;  
  5. import lombok.extern.log4j.Log4j;  
  6. @Data 
  7. @NoArgsConstructor 
  8. @AllArgsConstructor 
  9. @Log4j 
  10. @Builder 
  11. public class User { 
  12. //姓名 
  13. private String name; 
  14. //年龄 
  15. private Integer age; 
  16. //性别 
  17. private Integer sex; 
  18. //所在省市 
  19. private String address; 

这里用lombok简化了实体类的代码。

然后创建需要的集合数据,也就是源数据:

  1. //1.构建我们的list 
  2. List<User> list= Arrays.asList( 
  3.         new User("钢铁侠",40,0,"华盛顿"), 
  4.         new User("蜘蛛侠",20,0,"华盛顿"), 
  5.         new User("赵丽颖",30,1,"湖北武汉市"), 
  6.         new User("詹姆斯",35,0,"洛杉矶"), 
  7.         new User("李世民",60,0,"山西省太原市"), 
  8.         new User("蔡徐坤",20,1,"陕西西安市"), 
  9.         new User("葫芦娃的爷爷",70,0,"山西省太原市"
  10. ); 

3.1 过滤

1)创建流 stream() / parallelStream()

  • stream() : 串行流

  • parallelStream(): 并行流

2)filter 过滤(T-> boolean)

比如要过滤年龄在40岁以上的用户,就可以这样写:

  1. List<User> filterList = list.stream().filter(user -> user.getAge() >= 40
  2.         .collect(toList()); 

filter里面,->箭头后面跟着的是一个boolean值,可以写任何的过滤条件,就相当于sql中where后面的东西,换句话说,能用sql实现的功能这里都可以实现

打印结果:

简洁方便的集合处理——Java 8 stream流

3)distinct 去重

和sql中的distinct关键字很相似。为了看到效果,此处在原集合中加入一个重复的人,就选择钢铁侠吧,复联4钢铁侠不幸遇害,大家还是比较伤心的。

  1. List<User> list= Arrays.asList( 
  2.         new User("钢铁侠",40,0,"华盛顿"), 
  3.         new User("钢铁侠",40,0,"华盛顿"), 
  4.         new User("蜘蛛侠",20,0,"华盛顿"), 
  5.         new User("赵丽颖",30,1,"湖北武汉市"), 
  6.         new User("詹姆斯",35,0,"洛杉矶"), 
  7.         new User("李世民",60,0,"山西省太原市"), 
  8.         new User("蔡徐坤”,18,1,"陕西西安市"), 
  9.         new User("葫芦娃的爷爷",70,0,"山西省太原市"
  10. ); 
  1. //distinct 去重 
  2. List<User> distinctList = filterList.stream().distinct() 
  3.         .collect(toList()); 

打印结果:

简洁方便的集合处理——Java 8 stream流

4)sorted排序

如果流中的元素的类实现了 Comparable 接口,即有自己的排序规则,那么可以直接调用 sorted() 方法对元素进行排序,如: 

  1. Comparator.comparingInt 

反之, 需要调用 sorted((T, T) -> int) 实现 Comparator 接口。

  1. //sorted() 
  2. List<User> sortedList = distinctList.stream().sorted(Comparator.comparingInt(User::getAge)) 
  3.         .collect(toList()); 

打印结果:

简洁方便的集合处理——Java 8 stream流

结果按照年龄从小到大进行排序。

5)limit() 返回前n个元素

如果想知道这里面年龄最小的是谁,可作如下操作:

  1. //limit 返回前n个元素 
  2. List<User> limitList = sortedList.stream().limit(1
  3.         .collect(toList()); 

简洁方便的集合处理——Java 8 stream流

6)skip()

与limit恰恰相反,skip的意思是跳过,也就是去除前n个元素。

打印结果:

简洁方便的集合处理——Java 8 stream流

果然,前两个人都被去除了,只剩下最老的葫芦娃爷爷。

3.2 映射

1)map(T->R)

map是将T类型的数据转为R类型的数据,比如我们想要设置一个新的list,存储用户所有的城市信息。

  1. //map(T->R) 
  2. List<String> cityList = list.stream().map(User::getAddress).distinct().collect(toList()); 

打印结果:

简洁方便的集合处理——Java 8 stream流

2)flatMap(T -> Stream)

将流中的每一个元素 T 映射为一个流,再把每一个流连接成为一个流。

  1. //flatMap(T -> Stream<R>) 
  2. List<String> flatList = new ArrayList<>(); 
  3. flatList.add("唱,跳"); 
  4. flatList.add("rape,篮球,music"); 
  5. flatList = flatList.stream().map(s -> s.split(",")).flatMap(Arrays::stream).collect(toList()); 

打印结果:

简洁方便的集合处理——Java 8 stream流

这里原集合中的数据由逗号分割,使用split进行拆分后,得到的是Stream<string[] style="text-align: justify;-webkit-print-color-adjust: exact;">,字符串数组组成的流,要使用flatMap的</string[]>

Arrays::stream

将Stream<string[] style="-webkit-print-color-adjust: exact;">转为Stream,然后把流相连接,组成了完整的唱、跳、rap、篮球和music。</string[]>

3.3 查找

1)allMatch(T->boolean)

检测是否全部满足参数行为,假如这些用户是网吧上网的用户名单,那就需要检查是不是每个人都年满18周岁了。

  1. boolean isAdult = list.stream().allMatch(user -> user.getAge() >= 18); 

打印结果:

  1. true 

2)anyMatch(T->boolean)

检测是否有任意元素满足给定的条件,比如,想知道同学名单里是否有女生。

  1. //anyMatch(T -> boolean) 是否有任意一个元素满足给定的条件 
  2. boolean isGirl = list.stream().anyMatch(user -> user.getSex() == 1); 

打印结果:

  1. true 

说明集合中有女生存在。

3)noneMatch(T -> boolean)

流中是否有元素匹配给定的 T -> boolean 条件。

比如检测有没有来自巴黎的用户。

  1. boolean isLSJ = list.stream().noneMatch(user -> user.getAddress().contains("巴黎")); 

打印结果:

  1. true 

打印true说明没有巴黎的用户。

4)findFirst( ):找到***个元素

  1. Optional<User> fristUser  = list.stream().findFirst(); 

打印结果:

  1. User(name=钢铁侠, age=40, sex=0, address=华盛顿) 

5)findAny():找到任意一个元素

  1. Optional<User> anyUser  = list.stream().findAny(); 

打印结果:

  1. User(name=钢铁侠, age=40, sex=0, address=华盛顿) 

这里我们发现findAny返回的也总是***个元素,那么为什么还要进行区分呢?因为在并行流 parallelStream() 中找到的确实是任意一个元素。

  1. Optional<User> anyParallelUser  = list.parallelStream().findAny(); 

打印结果 :

  1. Optional[User(name=李世民, age=60, sex=0, address=山西省太原市)] 

3.4 归纳计算

1)求用户的总人数

  1. long count = list.stream().collect(Collectors.counting()); 

我们可以简写为:

  1. long count = list.stream().count(); 

运行结果:

  1. 8 

2)得到某一属性的***最小值

  1. // 求***年龄  
  2. Optional<User> max = list.stream().collect(Collectors.maxBy(  
  3. Comparator.comparing(User::getAge)));  
  4. // 求最小年龄 
  5. Optional<User> min = list.stream().collect(Collectors.minBy( 
  6. Comparator.comparing(User::getAge))); 

运行结果

简洁方便的集合处理——Java 8 stream流

简洁方便的集合处理——Java 8 stream流

3)求年龄总和是多少

  1. // 求年龄总和 
  2. int totalAge = list.stream().collect(Collectors.summingInt(User::getAge)); 

运行结果:

  1. 313 

我们经常会用BigDecimal来记录金钱,假设想得到BigDecimal的总和:

  1. // 获得列表对象金额, 使用reduce聚合函数,实现累加器 
  2. BigDecimal sum = myList.stream() .map(User::getMoney) 
  3. .reduce(BigDecimal.ZERO,BigDecimal::add); 

4)求年龄平均值

  1. //求年龄平均值 
  2. double avgAge = list.stream().collect( 
  3. Collectors.averagingInt(User::getAge)); 

运行结果:

  1. 39.125 

5)一次性得到元素的个数、总和、***值、最小值

  1. IntSummaryStatistics statistics = list.stream().collect( 
  2. Collectors.summarizingInt(User::getAge)); 

运行结果:

简洁方便的集合处理——Java 8 stream流

6)字符串拼接

要将用户的姓名连成一个字符串并用逗号分割。

  1. String names = list.stream().map(User::getName) 
  2. .collect(Collectors.joining(", ")); 

运行结果:

  1. 钢铁侠, 钢铁侠, 蜘蛛侠, 赵丽颖, 詹姆斯, 李世民, 蔡徐坤, 葫芦娃的爷爷 

3.5 分组

在数据库操作中,我们经常通过GROUP BY关键字对查询到的数据进行分组,java8的流式处理也提供了分组的功能。使用Collectors.groupingBy来进行分组。

1)可以根据用户所在城市进行分组

  1. Map<String, List<User>> cityMap = list.stream() 
  2. .collect(Collectors.groupingBy(User::getAddress)); 

简洁方便的集合处理——Java 8 stream流

结果是一个map,key为不重复的城市名,value为属于该城市的用户列表。已经实现了分组。

2)二级分组,先根据城市分组再根据性别分组

  1. Map<String, Map<Integer, List<User>>> group = list.stream().collect( 
  2.         Collectors.groupingBy(User::getAddress, // 一级分组,按所在地区 
  3.                 Collectors.groupingBy(User::getSex))); // 二级分组,按性别 

运行结果:

简洁方便的集合处理——Java 8 stream流

3)如果仅仅想统计各城市的用户个数是多少,并不需要对应的list

按城市分组并统计人数:

  1. Map<String, Long> cityCountMap = list.stream() 
  2. .collect(Collectors.groupingBy(User::getAddress,Collectors.counting())); 

运行结果:

简洁方便的集合处理——Java 8 stream流

4)当然,也可以先进行过滤再分组并统计人数

  1. Map<String,Long> map = list.stream().filter(user -> user.getAge() <= 30
  2.         .collect(Collectors.groupingBy(User::getAddress,Collectors.counting())); 

运行结果:

简洁方便的集合处理——Java 8 stream流

5)partitioningBy 分区

分区与分组的区别在于,分区是按照 true 和 false 来分的,因此partitioningBy 接受的参数的 lambda 也是 T -> boolean

  1. //根据年龄是否小于等于30来分区 
  2. Map<Boolean, List<User>> part = list.stream() 
  3.         .collect(partitioningBy(user -> user.getAge() <= 30)); 

运行结果:

简洁方便的集合处理——Java 8 stream流

总结

到目前为止,stream的功能我们已经用了很多了,感觉有点眼花缭乱却无所不能,stream能做的事情远远不止这些。

我们可以多学习使用stream,把原来复杂的sql查询,一遍又一遍地for循环的复杂代码重构,让代码更简洁易懂,可读性强。

【本文是51CTO专栏机构宜信技术学院的原创文章,微信公众号“宜信技术学院( id: CE_TECH)”】

戳这里,看该作者更多好文

【责任编辑:张燕妮 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢