解决Java8 分组groupingBy 后排序不变的问题

在工作中遇到了java8 stream groupBy 分组排序失效的问题

在此记录一下解决方案：

预期效果： 按照年纪倒序并分组

实际结果：返回的数据是杂乱无章，并没有按照年纪倒序
示例代码如下：

import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * @author miao
 */
public class GroupBySort {

    public static void main(String[] args) {
        //构造数据
        List<Student> students = Stream.of(
                new Student("a", 15),
                new Student("b", 13),
                new Student("c", 11),
                new Student("d", 18),
                new Student("e", 20)
        ).collect(Collectors.toList());

        //按照年纪倒序并分组
        Map<Integer, List<Student>> studentMap = students.stream()
                .sorted(Comparator.comparing(Student::getAge).reversed())
                .collect(Collectors.groupingBy(Student::getAge));

        System.out.println(studentMap);
    }
}

class Student {

    private String name;

    private Integer age;

    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

排查原因

查看java.util.stream.Collectors类的groupingBy方法，源码如下：

//一个入参
public static <T, K> Collector<T, ?, Map<K, List<T>>>
    groupingBy(Function<? super T, ? extends K> classifier) {
        return groupingBy(classifier, toList());
    }

//两个入参
public static <T, K, A, D>
    Collector<T, ?, Map<K, D>> groupingBy(Function<? super T, ? extends K> classifier,
                                          Collector<? super T, A, D> downstream) {
        return groupingBy(classifier, HashMap::new, downstream);
    }

//三个入参（最终的方法）
public static <T, K, D, A, M extends Map<K, D>>
    Collector<T, ?, M> groupingBy(Function<? super T, ? extends K> classifier,
                                  Supplier<M> mapFactory,
                                  Collector<? super T, A, D> downstream) {...}

在第二个方法中我们可知，groupingBy接口调用自己的方法时创建了一个 HashMap （ HashMap::new）。因为**hashMap,是无序的 **，是根据key的hashcode进行hash，然后放入对应的地方。所以在按照一定顺序put进HashMap中，然后遍历出HashMap的顺序跟put的顺序不同。所以才出现了上述的问题。

解决方案

因为这三个方法都是 public 类型的，我们可以直接外部调用，而入参给一个有序的Map就可以了，我选择的是LinkedHashMap。

文章最后面会简单介绍LinkedHashMap

示例代码如下

//按照年纪倒序并分页
        Map<Integer, List<Student>> studentMap = students.stream()
                .sorted(Comparator.comparing(Student::getAge).reversed())
                .collect(Collectors.groupingBy(Student::getAge, LinkedHashMap::new, Collectors.toList()));

结果如下：

LinkedHashMap 的介绍

• LinkedHashMap有序，HashMap无序
• LinkedHashMap是HashMap的子类，内部维护了一个双向链表保证元素插入时候的顺序，其增删改查的时间复杂度为O(1)
• LinkedHashMap的节点占用了更多的空间，包括指向前一个节点的指针before和指向后一个节点的after指针
• LinkedHashMap默认使用插入顺序进行遍历，也可以使用访问顺序进行遍历。将accessOrder置为true即可