Java中groupingBy的作用 详解流元素分组的实现方法

java中的groupingby方法用于将流中的元素按指定规则分组并返回map，其核心是通过function定义分组规则。1. 最基本形式为传入一个function确定分组key，如按person的age属性分组；2. 可搭配下游collector实现更复杂操作，如用collectors.counting()统计每组数量，或用collectors.mapping()映射元素生成新列表；3. groupingby支持多级分组，例如先按省份再按城市分组，通过嵌套使用groupingby完成；4. key可以为null，此时所有对应元素归为一组，但需注意性能和下游collector对null的支持；5. groupingby还可结合如toset、summingint、maxby等多种collector以满足不同数据处理需求。

Java中的groupingBy方法，简单来说，就是把一个流（Stream）里的元素按照你指定的规则分成不同的组，最后返回一个Map，这个Map的key就是分组的规则，value就是属于这个组的元素列表。它能让你更方便地处理集合数据，不用自己写循环和条件判断。

流元素分组的实现方法主要依赖于Collectors.groupingBy()这个静态方法。它有多种重载形式，可以满足不同的分组需求。最基本的形式是传入一个Function，这个Function定义了分组的规则。

解决方案

立即学习“Java免费学习笔记（深入）”；

groupingBy的核心在于定义分组的“规则”。这个规则通过Function接口来实现，这个Function接收流中的每个元素作为输入，返回一个值，这个值就是该元素所属的组的key。

例如，假设我们有一个List，Person类包含name和age两个属性，我们想按照年龄分组：

List<Person> people = Arrays.asList(
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 25),
    new Person("David", 30),
    new Person("Eve", 35)
);

Map<Integer, List<Person>> peopleByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge));

System.out.println(peopleByAge);
// 输出：{25=[Person{name='Alice', age=25}, Person{name='Charlie', age=25}], 30=[Person{name='Bob', age=30}, Person{name='David', age=30}], 35=[Person{name='Eve', age=35}]}

这里，Person::getAge就是一个Function，它接收一个Person对象，返回这个人的年龄。groupingBy方法会根据这个年龄把所有的人分成不同的组。

除了最简单的形式，groupingBy还支持更复杂的分组方式。例如，你可以指定一个下游的Collector，用于对每个组的元素进行进一步的处理。

比如，我们想按照年龄分组，但是只统计每个年龄段的人数，而不是把所有的人都放到一个List里：

Map<Integer, Long> countByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge, Collectors.counting()));

System.out.println(countByAge);
// 输出：{25=2, 30=2, 35=1}

这里，我们使用了Collectors.counting()作为下游的Collector，它会统计每个组的元素个数。

再比如，我们想按照年龄分组，但是只保留每个年龄段的人的名字列表：

Map<Integer, List<String>> namesByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge, Collectors.mapping(Person::getName, Collectors.toList())));

System.out.println(namesByAge);
// 输出：{25=[Alice, Charlie], 30=[Bob, David], 35=[Eve]}

这里，我们使用了Collectors.mapping()作为下游的Collector，它会把每个Person对象映射成一个名字，然后把所有的名字放到一个List里。

总之，groupingBy是一个非常强大的方法，它可以让你以各种方式对流中的元素进行分组。

groupingBy的key可以是null吗？如果key是null会发生什么？

groupingBy的key是可以为null的。如果key是null，那么所有key为null的元素会被分到同一个组。但是，你需要注意，如果你的数据中有大量的null key，可能会导致某个组的元素非常多，影响性能。此外，如果你的下游Collector不支持null值，可能会抛出NullPointerException。

例如：

List<String> names = Arrays.asList("Alice", null, "Bob", null, "Charlie");

Map<String, List<String>> groupedNames = names.stream()
    .collect(Collectors.groupingBy(name -> name));

System.out.println(groupedNames);
// 输出：{null=[null, null], Alice=[Alice], Bob=[Bob], Charlie=[Charlie]}

在这个例子中，null被当作一个有效的key，所有为null的元素都被分到了同一个组。

如何使用groupingBy进行多级分组？例如先按省份分组，再按城市分组

groupingBy支持多级分组，只需要在下游的Collector中再次使用groupingBy即可。

例如，假设我们有一个List

List<Address> addresses = Arrays.asList(
    new Address("Guangdong", "Guangzhou"),
    new Address("Guangdong", "Shenzhen"),
    new Address("Guangxi", "Nanning"),
    new Address("Guangxi", "Guilin")
);

Map<String, Map<String, List<Address>>> addressesByProvinceAndCity = addresses.stream()
    .collect(Collectors.groupingBy(Address::getProvince, Collectors.groupingBy(Address::getCity)));

System.out.println(addressesByProvinceAndCity);
// 输出：{Guangdong={Guangzhou=[Address{province='Guangdong', city='Guangzhou'}], Shenzhen=[Address{province='Guangdong', city='Shenzhen'}]}, Guangxi={Nanning=[Address{province='Guangxi', city='Nanning'}], Guilin=[Address{province='Guangxi', city='Guilin'}]}}

• Collectors.toSet(): 将每个组的元素收集到一个Set中，可以去重。
• Collectors.toMap(keyMapper, valueMapper): 将每个组的元素收集到一个Map中，需要指定key和value的映射规则。
• Collectors.averagingInt(ToIntFunction) / averagingLong(ToLongFunction) / averagingDouble(ToDoubleFunction): 计算每个组的平均值。
• Collectors.summingInt(ToIntFunction) / summingLong(ToLongFunction) / summingDouble(ToDoubleFunction): 计算每个组的总和。
• Collectors.maxBy(Comparator) / minBy(Comparator): 找出每个组的最大值/最小值。
• Collectors.reducing(identity, op): 对每个组的元素进行归约操作。
• Collectors.collectingAndThen(downstream, finisher): 对下游的Collector的结果进行进一步的处理。

例如，我们想按照年龄分组，然后找出每个年龄段年龄最大的人：

Map<Integer, Optional<Person>> oldestByAge = people.stream()
    .collect(Collectors.groupingBy(Person::getAge, Collectors.maxBy(Comparator.comparingInt(Person::getAge))));

System.out.println(oldestByAge);
// 输出：{25=Optional[Person{name='Charlie', age=25}], 30=Optional[Person{name='David', age=30}], 35=Optional[Person{name='Eve', age=35}]}

在这个例子中，我们使用了Collectors.maxBy(Comparator.comparingInt(Person::getAge))作为下游的Collector，它会找出每个年龄段年龄最大的人。注意，由于可能某个年龄段没有人，所以返回的是Optional。

总之，groupingBy的灵活性在于可以搭配各种不同的Collector，根据不同的需求对分组后的数据进行各种各样的处理。

以上就是Java中groupingBy的作用 详解流元素分组的实现方法的详细内容，更多请关注php中文网其它相关文章！