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

小灰灰 2021-01-12 01:41 659阅读 0赞

# 背景 #

java8已经发行了好几年，前段时间java12也已经问世，但平时的工作中，很多项目的环境还停留在java1.7中。但是java8的很多新特性都是革命性的，各种集合的优化，lambda表达式，所以我们还是要去了解java8的魅力。
 今天我们学习一下java8的Stream，并不需要理论基础，直接可以上手去用。
 起初我接触stream的原因，是我要搞一个用户收入消费的数据分析，起初的统计筛选分组都是打算用sql语言直接从mysql里得到结果来展现的。但是发现这样频繁地访问数据库，性能会收到很大的影响，分析速度会很慢。所以想访问一次数据库拿到所有数据，然后放到内存中去进行数据分析统计过滤。
 接着，我看了stream的api，发现这就是我想要的

## 一. Stream理解 ##

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

## 二. Stream流程 ##

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

Stream流的操作流程一般都是这样的，先将集合转为流，然后经过各种操作，比如过滤、筛选、分组、计算。最后的终端操作，就是转化成我们想要的数据，一般还是集合，有的时候我们想变成count计数，后面我们会一一举例  
![在这里插入图片描述][20190510171608978.png]

## 三. API功能举例 ##

首先，我们先定义一个用户对象，包含姓名，年龄，性别和籍贯四个成员变量：

import lombok.AllArgsConstructor;
    import lombok.Builder;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.extern.log4j.Log4j;
    
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    @Log4j
    @Builder
    public class User {
        //姓名
        private String name;
        //年龄
        private Integer age;
        //性别
        private Integer sex;
        //所在省市
        private String address;
    }

这里我们用lombok简化了实体类的代码  
然后我们创建我们需要的**集合数据**，也就是源数据：

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

### <1>. 过滤 ###

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

*  stream() : 串行流
 *  parallelStream（）: 并行流

#### 2. filter 过滤(T-> boolean) ####

比如我们要过滤年龄在40岁以上的用户，我们就可以这样写：

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

filter里面 ->箭头后面跟着的是一个**boolean值**，我们可以写任何的过滤条件，就相当于sql中where后面的东西，换句话说，**能用sql实现的功能这里都可以实现**  
打印结果：  
![在这里插入图片描述][20190510172742664.png]

#### 3. distinct 去重 ####

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

List<User> list= Arrays.asList(
            new User("钢铁侠",40,0,"华盛顿"),
            new User("钢铁侠",40,0,"华盛顿"),
            new User("蜘蛛侠",20,0,"华盛顿"),
            new User("赵丽颖",30,1,"湖北武汉市"),
            new User("詹姆斯",35,0,"洛杉矶"),
            new User("李世民",60,0,"山西省太原市"),
            new User("蔡徐坤”,18,1,"陕西西安市"),
            new User("葫芦娃的爷爷",70,0,"山西省太原市")
    );

//distinct 去重
    List<User> distinctList = filterList.stream().distinct()
            .collect(toList());

打印结果：  
![在这里插入图片描述][2019051017300241.png]

#### 4. sorted排序 ####

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

Comparator.comparingInt

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

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

打印结果：  
![在这里插入图片描述][20190510173114142.png]  
结果按照年龄从小到大进行排序

#### 5. limit（） 返回前n个元素 ####

比如我们想知道这里面年龄最小的第一位是谁

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

![在这里插入图片描述][20190510173225139.png]

#### 6. skip() ####

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

打印结果：  
![在这里插入图片描述][20190510173303223.png]  
果然，前两个人都被去除了，只剩下最老的葫芦娃爷爷。

### <2>. 映射 ###

#### 1. map(T->R) ####

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

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

打印结果：  
![在这里插入图片描述][20190510173432573.png]

#### 2. flatMap(T -> Stream) ####

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

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

打印结果：  
![在这里插入图片描述][20190510173517710.png]  
这里原集合中的数据由逗号分割，我们使用split进行拆分后，得到的是Stream<String\[\]>，字符串数组组成的流，我们要使用flatMap的

> Arrays::stream

将Stream<String\[\]>转为Stream,然后把流相连接，组成了完整的唱、跳、rap、篮球和music。

### <3>. 查找 ###

#### 1. allMatch（T->boolean） ####

检测是否全部满足参数行为，比如这些用户是网吧上网的用户名单，我们要检查是不是每个人都满足18岁了

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

打印结果：

true

#### 2.anyMatch（T->boolean） ####

检测是否有任意元素满足给定的条件，比如，我们比较关心同学里是否有妹子

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

打印结果：

true

说明集合中有妹子存在

#### 3. noneMatch(T -> boolean) ####

流中是否没有元素匹配给定的 T -> boolean 条件  
比如我们检测有没有来自巴黎的用户

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

打印结果：

true

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

#### 4. findFirst( ):找到第一个元素 ####

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

打印结果：

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

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

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

打印结果：

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

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

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

打印结果 :

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

#### <4>. 归纳计算 ####

#### 1. 求用户的总人数 ####

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

我们可以简写为：

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

运行结果：

#### 2. 得到某一属性的最大最小值 ####

// 求最大年龄
    Optional<User> max = list.stream().collect(Collectors.maxBy(
    Comparator.comparing(User::getAge)));
    
    // 求最小年龄
    Optional<User> min = list.stream().collect(Collectors.minBy(
    Comparator.comparing(User::getAge)));

运行结果：  
![在这里插入图片描述][20190510174356172.png]  
![在这里插入图片描述][20190510174407356.png]

#### 3. 求年龄总和是多少 ####

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

运行结果：

313

我们经常会用BigDecimal来记录金钱，我们想得到BigDecimal的总和

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

#### 4. 求年龄平均值 ####

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

运行结果:

39.125

#### 5. 一次性得到元素的个数、总和、最大值、最小值 ####

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

运行结果：  
![在这里插入图片描述][20190510174632906.png]

#### 6. 字符串拼接 ####

比如我们要将用户的姓名连成一个字符串并用逗号分割

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

运行结果：

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

#### <5>. 分组 ####

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

#### 1.我们可以根据用户所在城市进行分组 ####

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTE5NDE1_size_16_color_FFFFFF_t_70]  
结果是一个map，key为不重复的城市名，value为属于该城市的用户列表。已经实现了分组

#### 2. 二级分组，先根据城市分组再根据性别分组 ####

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

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTE5NDE1_size_16_color_FFFFFF_t_70 1]

#### 3. 如果我们仅仅想统计一下各城市的用户个数是多少，并不需要对应的list ####

按城市分组并统计人数：

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

运行结果：![在这里插入图片描述][20190510182526338.png]

#### 4. 当然，我们也可以先进行过滤再分组并统计人数 ####

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

运行结果：  
![在这里插入图片描述][20190510182623823.png]

#### 5.partitioningBy 分区 ####

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

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

运行结果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTE5NDE1_size_16_color_FFFFFF_t_70 2]

## 总结 ##

到目前为止，stream的功能我们已经用了很多了，感觉有点眼花缭乱却无所不能，stream能做的事情远远不止这些。  
我们可以多去学习使用stream，把我们原来复杂的sql查询，一遍又一遍地for循环的复杂代码重构，让我们的代码更**简洁易懂，可读性强。**

[20190510171608978.png]: /images/1610415675977.png
[20190510172742664.png]: /images/1610415653050.png
[2019051017300241.png]: /images/1610415632524.png
[20190510173114142.png]: /images/1610415612893.png
[20190510173225139.png]: /images/1610415592634.png
[20190510173303223.png]: /images/1610415569938.png
[20190510173432573.png]: /images/1610415544731.png
[20190510173517710.png]: /images/1610415522250.png
[20190510174356172.png]: /images/1610415498970.png
[20190510174407356.png]: /images/1610415477066.png
[20190510174632906.png]: /images/1610415453716.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTE5NDE1_size_16_color_FFFFFF_t_70]: /images/1610415430410.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTE5NDE1_size_16_color_FFFFFF_t_70 1]: /images/1610415405114.png
[20190510182526338.png]: /images/1610415383970.png
[20190510182623823.png]: /images/1610415356877.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNTE5NDE1_size_16_color_FFFFFF_t_70 2]: /images/1610415330284.png