Java 8 lambda Collectors优雅的使用方式-超详细-groupingBy分组自定义比较器

背景

在使用Java8进行分组的时候，有的时候需要分组返回的数据是固定的，这个就需要指定分组使用的map类型，以下是一些案例

数据准备 

实体类 (Student)

public class Student {
        /**
         * 班级
         */
        private String grade;
        /**
         * 年龄
         */
        private int age;

        public Student(String grade, int age) {
            this.grade = grade;
            this.age = age;
        }

        public String getGrade() {
            return grade;
        }

        public void setGrade(String grade) {
            this.grade = grade;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

排序枚举类 

public enum SortEnum {
        SIX("六年级", 1),
        SEVEN("七年级", 2),
        NINE("九年级", 3),
        OTHER("其他", -1);

        private SortEnum(String name, Integer value) {
            this.value = value;
            this.name = name;
        }

        public Integer getValue() {
            return value;
        }

        private Integer value;

        public String getName() {
            return name;
        }

        private String name;

        public static Integer getSort(String name) {
            if (name == null) {
                return OTHER.getValue();
            }
            SortEnum[] instances = SortEnum.values();
            for (SortEnum i : instances) {
                if (name != null && name.equals(i.getName())) {
                    return i.getValue();
                }
            }
            return OTHER.getValue();
        }
    }

 

测试类 (Main方法)

    public static void main(String[] args) {
        Student t1 = new Student("六年级", 23);
        Student t2 = new Student("六年级", 14);
        Student t3 = new Student("六年级", 56);
        Student t4 = new Student("九年级", 56);
        Student t5 = new Student("九年级", 16);
        Student t6 = new Student("九年级", 36);
        Student t7 = new Student("七年级", 56);
        Student t8 = new Student("七年级", 16);
        Student t9 = new Student("七年级", 36);
        List<Student> list = Lists.newArrayList(t1, t2, t3, t4, t5, t6, t7, t8, t9);

        //根据班级分组
        list.stream().collect(Collectors.groupingBy(Student::getGrade));
}

分组后的集合是有序的写法

根据集合中元素的年龄属性排序

Map<String, List<Student>> collect1 = list.stream().sorted(Comparator.comparingInt(Student::getAge))
.collect(Collectors.groupingBy(Student::getGrade));
System.out.println(collect1);
//输出
{九年级=[Student{grade='九年级', age=16}, Student{grade='九年级', age=36}, Student{grade='九年级', age=56}],
七年级=[Student{grade='七年级', age=16}, Student{grade='七年级', age=36}, Student{grade='七年级', age=56}],
六年级=[Student{grade='六年级', age=14}, Student{grade='六年级', age=23}, Student{grade='六年级', age=56}]}

需要分组的key是有序的

分组后发现年级是无序的 ，Collectors中的groupingBy有三个重载方法，默认分组后的数据是HashMap导致显示的时候是无序的，分组的集合默认是List，所以如果想要key是有序的话，就需要使用有序的Map，可以选择LinkedHashMap或者是TreeMap

 

 LinkedHashMap写法

按照放进去的先后显示能满足数据不会变化的要求，但是不能满足排序的要求

Map<String, List<Student>> collect2 = list.stream().collect(
Collectors.groupingBy(Student::getGrade, LinkedHashMap::new, Collectors.toList()));

TreeMap写法

能满足排序的要求，默认按照自然排序的方式显示，如果是复杂对象就需要传入一个比较器进行比较

Map<String, List<Student>> collect3 = list.stream().collect(
Collectors.groupingBy(Student::getGrade, TreeMap::new, Collectors.toList()));

 TreeMap写法（自定义比较器）

Map<String, List<Student>> collect4 = list.stream().collect(Collectors.groupingBy(
Student::getGrade,() -> new TreeMap<>(Comparator.comparing(SortEnum::getSort)), Collectors.toList()));

 来看一下这个写法的演变过程

其实就是将其中的代码替换成对应的lambda表达式

Map<String, List<Student>> collect4 = list.stream().sorted(Comparator.comparingInt(Student::getAge)).collect(
Collectors.groupingBy(Student::getGrade, () -> {
                    return new TreeMap<>(new Comparator<String>() {
                        @Override
                        public int compare(String o1, String o2) {
                            return SortEnum.getSort(o1).compareTo(SortEnum.getSort(o2));
                        }
                    });
                }, Collectors.toList()));

 

  Map<String, List<Student>> collect4 = list.stream().sorted(Comparator.comparingInt(Student::getAge)).collect(
Collectors.groupingBy(Student::getGrade, () -> {
                    return new TreeMap<>((o1, o2) -> SortEnum.getSort(o1).compareTo(SortEnum.getSort(o2)));
                }, Collectors.toList()));

Map<String, List<Student>> collect4 = list.stream().sorted(Comparator.comparingInt(Student::getAge)).collect(
Collectors.groupingBy(Student::getGrade, () -> new TreeMap<>((o1, o2) ->
 SortEnum.getSort(o1).compareTo(SortEnum.getSort(o2))), Collectors.toList()));

 Map<String, List<Student>> collect4 = list.stream().sorted(Comparator.comparingInt(Student::getAge)).collect(
Collectors.groupingBy(Student::getGrade, () -> new TreeMap<>(Comparator.comparing(SortEnum::getSort)), Collectors.toList()));

因为枚举中设置了序号，因此输出的结果是

//LinkedMap输出 - 集合未排序
{六年级=[Student{grade='六年级', age=23}, Student{grade='六年级', age=14}, Student{grade='六年级', age=56}], 
九年级=[Student{grade='九年级', age=56}, Student{grade='九年级', age=16}, Student{grade='九年级', age=36}], 
七年级=[Student{grade='七年级', age=56}, Student{grade='七年级', age=16}, Student{grade='七年级', age=36}]}

//TreeMapMap默认输出- 集合未排序
{七年级=[Student{grade='七年级', age=56}, Student{grade='七年级', age=16}, Student{grade='七年级', age=36}], 
九年级=[Student{grade='九年级', age=56}, Student{grade='九年级', age=16}, Student{grade='九年级', age=36}], 
六年级=[Student{grade='六年级', age=23}, Student{grade='六年级', age=14}, Student{grade='六年级', age=56}]}

//TreeMap自定义比较器输出 - 集合已排序
{六年级=[Student{grade='六年级', age=14}, Student{grade='六年级', age=23}, Student{grade='六年级', age=56}], 
七年级=[Student{grade='七年级', age=16}, Student{grade='七年级', age=36}, Student{grade='七年级', age=56}], 
九年级=[Student{grade='九年级', age=16}, Student{grade='九年级', age=36}, Student{grade='九年级', age=56}]}