Java Stream按组取最大元素

Java Stream 按组取最大元素，核心不是先把所有数据排序，而是把 groupingBy 和组内的 maxBy 组合起来：前者负责按字段分组，后者负责在每个组里比较并保留一个对象。这样可以直接得到“每个部门最高薪员工”这类结果，同时保留员工的姓名、编号等完整字段。

官方地址：https://docs.oracle.com/en/java/javase/26/docs/api/

下面用一个很小的 Java 项目串起完整写法。假设输入是员工集合，目标结果是 Map，而不是每组只留下一个薪资数字。

先把结果类型想清楚

普通的 groupingBy(Employee::department) 得到的是 Map>：每个部门对应一组员工。要改成每个部门只保留最高薪员工，就需要把第二个参数换成下游收集器：

// groupingBy 负责部门归类，maxBy 负责每个部门内部的最大值选择
Map> grouped = employees.stream()
        // 可空薪资先排除，避免比较器自动拆箱时遇到 null
        .filter(employee -> employee.salary() != null)
        .collect(Collectors.groupingBy(
                Employee::department,
                Collectors.maxBy(Comparator.comparingInt(Employee::salary))));

这里的返回值是 Map>，因为官方 API 将 maxBy 定义为返回一个描述最大元素的 Optional。对正常的非空分组来说，组内会有一个最大员工；Optional 主要是让收集器的空输入语义保持明确。

用 groupingBy 嵌套 maxBy 取每组最大对象

把示例补成一个可复用的小项目时，先定义一条员工记录，再用部门作为分组键、薪资作为比较字段：

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

public class GroupMaxDemo {
    // record 让示例只关注分组和比较，不引入无关的 getter 样板代码
    record Employee(String department, long id, String name, Integer salary) {}

    public static Map> maxByDepartment(
            List employees) {
        // 可空薪资先排除，第二个收集器才在组内找薪资最大值
        return employees.stream()
                .filter(employee -> employee.salary() != null)
                .collect(Collectors.groupingBy(
                        Employee::department,
                        Collectors.maxBy(
                                Comparator.comparingInt(Employee::salary))));
    }
}

这段代码的关键是 groupingBy 的第二个参数。它不是在整个员工集合中找一个最大值，而是对每个部门分别应用一次 maxBy。因此结果仍然保留了员工对象，调用方还可以继续读取 name 和 id。

按示例数据理解，结果结构类似下面这样；它表示每个部门只剩一条员工记录：

研发 -> Optional[Employee[department=研发, id=102, name=李宁, salary=26000]]
销售 -> Optional[Employee[department=销售, id=203, name=周敏, salary=18000]]

把 Optional 收敛成 Map

如果业务层不希望到处处理 Optional，可以把 maxBy 再包一层 collectingAndThen。它先执行下游收集器，再使用 finisher 把结果转换成目标类型：

public static Map topByDepartment(
        List employees) {
    // 每个实际出现的部门至少有一个元素，因此这里可以安全收敛 Optional
    return employees.stream()
            // 业务规则：没有薪资的员工不参与“最高薪”比较
            .filter(employee -> employee.salary() != null)
            .collect(Collectors.groupingBy(
                    Employee::department,
                    Collectors.collectingAndThen(
                            Collectors.maxBy(
                                    Comparator.comparingInt(Employee::salary)),
                            optional -> optional.orElseThrow())));
}

最终类型变成 Map。要注意，空输入得到的是空 Map，并不会凭空产生一个“空部门”；orElseThrow() 处理的是已经进入某个分组的结果，而不是制造缺失的分组。

并列最大值和空值怎么处理

如果两个员工薪资相同，单独使用薪资比较器只说明二者“相等”，不会表达你希望留下哪一条。可以追加一个稳定的次级条件，例如员工编号较大的记录优先：

public static Map topByDepartmentWithTieBreak(
        List employees) {
    // 先比薪资，再比编号，让并列最大值也有明确规则
    Comparator bySalaryThenId = Comparator
            .comparingInt(Employee::salary)
            .thenComparingLong(Employee::id);

    // 保持完整对象，避免先 map 成薪资后丢失员工信息
    return employees.stream()
            // 没有薪资的记录先排除，避免 comparingInt 自动拆箱 null
            .filter(employee -> employee.salary() != null)
            .collect(Collectors.groupingBy(
                    Employee::department,
                    Collectors.collectingAndThen(
                            Collectors.maxBy(bySalaryThenId),
                            optional -> optional.orElseThrow())));
}

如果薪资字段允许为 null，不要直接把可空的 Integer 交给 comparingInt，因为自动拆箱可能触发空指针。更清楚的做法是先明确业务规则：

// 这里把没有薪资的员工排除；若业务要保留它们，应改用显式的 null 比较器
List payable = employees.stream()
        .filter(employee -> employee.salary() != null)
        .toList();

同样重要的是，thenComparing 只是补充比较规则，不会把薪资相同的员工变成多个结果；每个分组仍然只会收敛为一个对象。

什么时候该换成其他写法

并行流也要谨慎。官方文档指出，普通 groupingBy 收集器不是并发收集器，平行归约时合并 Map 可能有额外成本；数据量不大或结果需要稳定顺序时，顺序流通常更容易解释。

最后记住这一条组合公式

Java Stream 按组取最大元素可以固定成下面的思路：

// 分组键决定“每组是谁”，比较器决定“组内谁最大”
Map result = values.stream()
        .collect(Collectors.groupingBy(
                value -> groupKey(value),
                Collectors.collectingAndThen(
                        Collectors.maxBy(comparator),
                        optional -> optional.orElseThrow())));

先确认结果需要完整对象还是单个字段，再决定是否收敛 Optional；遇到并列值就补充 thenComparing，遇到可空字段则先明确过滤还是使用空值比较规则。这样写出来的 Stream 管道短，但分组、比较和异常边界都能被读者直接看懂。

相关问题

每组有多个并列最大值怎么办？

maxBy 只返回一个元素。若必须保留全部并列项，应先按组收集列表，再计算最大值后过滤，或者改用专门的多结果收集逻辑。

为什么结果是 Optional？

因为 maxBy 的收集器契约用 Optional 表达没有最大元素的情况。对实际分组而言，分组存在就至少有一个输入；是否使用 orElseThrow 取决于你的空数据策略。

能不能直接先排序再取每组第一条？

可以，但通常会保留更多中间数据，也要额外表达分组内排序。只要目标是每组一个最大对象，groupingBy + maxBy 更贴近问题本身。