Java 通过 groupingBy 进行快速分组

Map<String, List<Bean>> lifeMap = list.stream().collect(Collectors.groupingBy(Bean::getDate));

list.stream() 中的 list 是等待处理的 List 数据集合

public class Bean implements Serializable {
    private String date;//日期
    private String type;//类型ID, 1,2,3,5
   
    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

/*
    {
      "date": "2023-1-1",
      "type": "1"
    },
     */

运行之后会发现按照上面的 groupBy 进行分组后，返回的数据是杂乱无章的，没有按照原来 list 的顺序返回，这种情况下应该怎么解决呢？

查看Java 的 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)

LinkedHashMap<String, List<Bean>> lifeMap = list.stream().collect(Collectors.groupingBy(Bean::getDate, LinkedHashMap::new, Collectors.toList()));

所以当我们需要有顺序的数据时，可以直接直接调用三个参数的 groupingBy 方法，向 mapFactory 传入有顺序的 Map，比如 LinkedHashMap。

 LinkedHashMap<String, List<Bean>> lifeMap = list.stream()
                                .collect(Collectors.groupingBy(Bean::getDate, LinkedHashMap::new, Collectors.toList()));

这样就可以按日期分组，排序后保证分组后顺序不变。