将List集合分成分组成map在工作中常常会遇到。这里我总结了两种方式：Lambda表达式方式和传统方式。

前期准备

先创建一个User类，用于分类

class User{
    private Integer age;

    private String name;

    public User(Integer age, String name) {
        this.age = age;
        this.name = name;
    }
  // 省略get、set方法
    @Override
    public String toString() {
        return "User{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

测试类中写个打印方法，一目了然就可以看到分组

void printMap(Map<Integer, List<User>> map){
        for (Map.Entry<Integer, List<User>> entry : map.entrySet()) {
            Integer key = entry.getKey();
            List<User> value = entry.getValue();
            System.out.println("key="+key+", value="+value);
        }
    }
1
2
3
4
5
6
7

实操

先在测试类中创建一个User集合并初始化

public class CommonTest {

    private final List<User> list;
    {
        list = new ArrayList<>();
        list.add(new User(16, "16_1"));
        list.add(new User(16, "16_2"));
        list.add(new User(16, "16_3"));

        list.add(new User(12, "12_1"));
        list.add(new User(12, "12_2"));
        list.add(new User(12, "12_3"));

        list.add(new User(14, "14_1"));
        list.add(new User(14, "14_2"));
        list.add(new User(14, "14_3"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Lambda表达式方式

Lambda表达式主要用到的是Collectors#groupingBy和partitioningBy。二者又有所不同：

• groupingBy 可以将list按条件分成多组，返回的对象Map>形式
• partitioningBy 只能将list按条件分为两组，返回的对象是Map>形式

groupingBy分组

话不多说看代码

@Test
public void testGroupingBy(){
    Map<Integer, List<User>> map = list.stream()
            .collect(Collectors.groupingBy(User::getAge));
    printMap(map);
}
1
2
3
4
5
6

结果：

key=16, value=[User{age=16, name='16_1'}, User{age=16, name='16_2'}, User{age=16, name='16_3'}]
key=12, value=[User{age=12, name='12_1'}, User{age=12, name='12_2'}, User{age=12, name='12_3'}]
key=14, value=[User{age=14, name='14_1'}, User{age=14, name='14_2'}, User{age=14, name='14_3'}]
1
2
3

可以看到通过groupingBy只需一行代码就将list分组成map。groupingBy除了可以分组以外还可以利用Collectors类的其他方法进行统计或者也可以将value分组成其他集合类。

partitioningBy 分组

将user按照年龄分组

@Test
public void testPartitioningBy(){
    Map<Boolean, List<User>> map = list.stream()
            .collect(Collectors.partitioningBy(user -> user.getAge() >= 14));

    for (Map.Entry<Boolean, List<User>> entry : map.entrySet()) {
        Boolean key = entry.getKey();
        List<User> value = entry.getValue();
        System.out.println("key="+key+", value="+value);
    }
}
1
2
3
4
5
6
7
8
9
10
11

结果：

key=false, value=[User{age=12, name='12_1'}, User{age=12, name='12_2'}, User{age=12, name='12_3'}]
key=true, value=[User{age=16, name='16_1'}, User{age=16, name='16_2'}, User{age=16, name='16_3'}, User{age=14, name='14_1'}, User{age=14, name='14_2'}, User{age=14, name='14_3'}]
1
2

通过partitioningBy将list分成了两组，key是Boolean类型。所以partitioningBy的分组条件必须是一个Boolean类型的结果。

传统方式

传统方式就是自己去手动地实现分组逻辑。传统方式也是可以分为两种方式的。

1. 手动创建Map对象

@Test
public void testMap(){
    Map<Integer, List<User>> map = new HashMap<>();
    for (User user : list) {
        Integer age = user.getAge();
        List<User> values = map.getOrDefault(age, new ArrayList<>());
        values.add(user);
        map.put(age, values);
    }
    printMap(map);
}
1
2
3
4
5
6
7
8
9
10
11

这种方式就是代码量相对大一点，但是同样也能实现分组的效果

2. 手动创建一个MultiValueMap对象

这种方式跟上面那种手动方式差不多，但是更简单一点。

@Test
public void testMultiValueMap(){
    MultiValueMap<Integer, User> map = new LinkedMultiValueMap<>();
    for (User user : list) {
        Integer age = user.getAge();
        map.add(age, user);
    }
    printMap(map);
}
1
2
3
4
5
6
7
8
9

类似MultiValueMap的工具类应该也有很多，本文的MultiValueMap是org.springframework.util包下的一个工具类。MultiValueMap也是Map的实现类，但是限定了value必须是List集合。同时它又增加了自己的方法以实现value是List集合的形式。MultiValueMap实现类有好几个，要使用LinkedMultiValueMap才是我们要的list集合分组，添加value的时候用的是add方法而不是put方法。

总结

通过对比可以发现使用Lambda表达式的方式进行分组代码量更少一点，但是要求对Lambda表达式要熟悉。根据业务可以使用groupingBy分多组，也可以使用partitioningBy分两组。传统方式一眼就能让人看明白，可读性更好，使用传统方式的话优先还是选择MultiValueMap更为简单。