Java Stream 处理分组后取每组最大&Stream流之list转map、分组取每组第一条&Java 8 Collectors：reducing 示例(List分组取最值)

桃扇骨 2023-09-30 23:33 13阅读 0赞

## Java Stream 处理分组后取每组最大 ##

有一个需求功能：先按照某一字段分组，再按照另外字段获取最大的那个

Map<String, HitRuleConfig> configMap = configList.parallelStream().collect(
     　　　　　　　　　　　　　　Collectors.groupingBy(HitRuleConfig::getAppId, // 先根据appId分组
    　　　　　　　　　　　　　　 Collectors.collectingAndThen(
    　　　　　　　　　　　　　　 Collectors.reducing(( c1,  c2) -> c1.getVersionSort() > c2.getVersionSort() ? c1 : c2), Optional::get)));

先根据appId分组，然后根据versionSort取最大.

## 【编程技巧】Stream流之list转map、分组取每组第一条 ##

## 前言 ##

JDK1.8推出的stream流能极大的简化对集合的操作，让代码更美观，老规矩，直接上代码。

## 一、list转map ##

取list中对象的某个属性作为唯一key，对象作为value形成一个map集合，能够便于在后续业务中取值而不用遍历list集合，使代码更优雅。

> 代码如下（示例）：

运行结果:  
![在这里插入图片描述][90e1619d57dc4c5ab6e30ac455c1d579.png]

## 二、分组取每组第一条数据 ##

通过分组取每组第一条数据的操作可以在很多场景适用，比如取多条数据中最新的一条数据等场景。

代码如下（示例）：

public class StreamSkill {
        
    
        public static void main(String[] args) {
        
            List<TestData> list = new ArrayList<>();
            TestData.TestDataBuilder builder = TestData.builder();
            builder.id(1).name("老王").age(50).address("隔壁");
            list.add(builder.build());
            builder.id(2).name("司马老贼").age(45).address("许昌");
            list.add(builder.build());
            builder.id(3).name("曹贼").age(43).address("许昌");
            list.add(builder.build());
            builder.id(4).name("大耳朵").age(52).address("益州");
            list.add(builder.build());
            builder.id(5).name("燕人").age(58).address("益州");
            list.add(builder.build());
    
            System.out.println(list);
    
            Map<String, TestData> map = list.stream().collect(
                    Collectors.groupingBy(TestData::getAddress, Collectors.collectingAndThen(
                            Collectors.reducing((t1, t2) -> t1.getAge() > t2.getAge() ? t1 : t2),
                            Optional::get
                    ))
            );
    
            System.out.println(map);
        }
    }
    
    
    @Data
    @Builder
    class TestData{
        
        private Integer id;
        private String name;
        private Integer age;
        private String address;
    }

运行结果：  
![在这里插入图片描述][ba2f36bbd2f04261a5afdbd330fdefee.png]  
从运行结果可以看出，根据address分组后取每组年龄最大的对象信息仅需要  
小小的几行代码就可以搞定

## 总结 ##

实际业务中根据业务合理利用stream流能够很大程度的简化代码，但是这种写法在出现bug的时候排查较为复杂，建议不要在使用stream流的时候在其中写太复杂的逻辑。

## Java 8 Collectors：reducing 示例(List分组取最值) ##

### 简介 ###

Java 8 `Collectors.reducing` 利用`Comparator(比较器)`和`BinaryOperator(二元运算符)`进行减少流中的元素。  
`Collectors.reducing`返回带有`Optional`数据的`Collector(收集器)`。

`Collectors.reducing` 在`Java` `Doc` 的方法语法如下。

public static <T> Collector<T,?,Optional<T>> reducing(BinaryOperator<T> op)

`Collectors.reducing`返回一个`Optional`类的收集器。

我们需要传递`BinaryOperator(二元运算符)`的`BinaryOperator.maxBy` 或`BinaryOperator.minBy`方法。

`BinaryOperator(二元运算符)`将`Comparator(比较器)`作为参数。

根据该`Comparator(比较器)`和`BinaryOperator(二元运算符)`，流元素被减少，最后可以作为一个组来收集。

### 使用场景 ###

`Collectors.reducing` 主要用于取`List`列表中的某一类型中的最大或最小的一个元素，例如下列代码，取出各个班级中年龄最大的学生信息。

注：如果最值相同，取列表顺序最先出现的一个。

### 代码示例 ###

**Student.java**

package com.concretepage.util;
    public class Student {
        
        private String name;
        private Integer age;
        private String className;
        public Student(String name,Integer age, String className){
        
            this.name=name;
            this.age=age;
            this.className = className;
        }
        public String getName() {
        
            return name;
        }
        public Integer getAge() {
        
            return age;
        }
        public String getClassName() {
        
            return className;
        }
    }

**ReducingDemo.java**

package com.concretepage.util;
    import java.util.Arrays;
    import java.util.Comparator;
    import java.util.List;
    import java.util.Map;
    import java.util.Optional;
    import java.util.function.BinaryOperator;
    import java.util.stream.Collectors;
    public class ReducingDemo {
        
        public static void main(String[] args) {
        
            Student s1 = new Student("Shyam", 22,"A");
            Student s2 = new Student("Ram",23,"A");
            Student s3 = new Student("Mohan",22,"B");
            Student s4 = new Student(null,21,"B");
            List<Student> list = Arrays.asList(s1,s2,s3,s4);
            Comparator<Student> ageComparator = Comparator.comparing(Student::getAge); 
            Map<String, Optional<Student>> eldestByClass = list.stream().collect(Collectors.groupingBy(Student::getClassName, 
                    Collectors.reducing(BinaryOperator.maxBy(ageComparator))));
            eldestByClass.forEach((k,v)->System.out.println("Class:"+k+" Age:"+
                    ((Optional<Student>)v).get().getAge()+" Name:"+((Optional<Student>)v).get().getName()));
        }
    }

输出

Class:A Age:23 Name:Ram
    Class:B Age:22 Name:Mohan

[90e1619d57dc4c5ab6e30ac455c1d579.png]: https://img-blog.csdnimg.cn/90e1619d57dc4c5ab6e30ac455c1d579.png
[ba2f36bbd2f04261a5afdbd330fdefee.png]: https://img-blog.csdnimg.cn/ba2f36bbd2f04261a5afdbd330fdefee.png