## 📋 目录

- 一、工具类功能
- 二、所需环境
- 三、方法与调用示例（按需调用）
- 四、工具类源码（可直接复制）

## 一、工具类功能

一批明细拿回来就按指定键分组，顺手计数、求和、算均值、取每组最大最小、把重复键压成单值、按笔数出榜单，不用再手写 Stream 收集器和临时累加。

## 二、所需环境

JDK 17或以上

## 三、方法与调用示例（按需调用）

🔢 **方法序号**：1

🎯 **方法用途**：
- 把一个集合按 key 归成「key 到该组全部元素」的 Map
- 省掉 `stream().collect(Collectors.groupingBy(...))` 那一串样板，还允许 key 是 `null`

🧩 **方法定义**：`public static <K, T> Map<K, List<T>> groupBy(Collection<? extends T> collection, Function<? super T, K> keyExtractor)`

🗣️ **入参解释**：`public static <K, T> Map<K, List<T>> groupBy(待分组集合, key提取函数)`

📤 **返回值解释**：`Map<K, List<T>>`，key 到该组元素列表，不为 `null`

💡 **边界口径**：
- 结果是 `LinkedHashMap`：key 按首次出现顺序排列，组内元素按入参顺序排列，Map 和列表都能接着改
- 提取函数返回 `null` 时，`null` 就是一个正常的分组键，这一组不会被丢掉
- 元素本身是 `null` 也照常入组，此时提取器必须兜住 `null`，写成 `Order::shop` 这种方法引用会抛 `NullPointerException`
- 集合或提取器传 `null` 抛 `IllegalArgumentException`，消息点名是哪个入参

🧪 **方法示例**：
- `groupBy(orders, Order::shop)` 拿到 `{望京店=[Order[shop=望京店, sku=A1, amount=38.0], Order[shop=望京店, sku=B7, amount=12.5], Order[shop=望京店, sku=A1, amount=7.5]], 国贸店=[Order[shop=国贸店, sku=A2, amount=60.0], Order[shop=国贸店, sku=C3, amount=20.0]], 西单店=[Order[shop=西单店, sku=A1, amount=99.0]]}`
- `groupBy(dirty, order -> order == null ? "本条无门店" : order.shop())` 拿到 `{null=[Order[shop=null, sku=X1, amount=5.0]], 本条无门店=[null], 望京店=[Order[shop=望京店, sku=X2, amount=8.0]]}`，`null` 键和 `null` 元素各自成了一组
- `groupBy(new ArrayList<>(), Order::shop)` 拿到 `{}`
- `groupBy(null, Order::shop)` 抛 `IllegalArgumentException: 待分组集合不能为null`

---

🔢 **方法序号**：2

🎯 **方法用途**：
- 把一个集合按 key 数出每组有几条，得到「key 到笔数」
- 计数按 key 复用同一个累加器，比逐元素 `Map.merge` 少一遍装箱

🧩 **方法定义**：`public static <K, T> Map<K, Long> countBy(Collection<? extends T> collection, Function<? super T, K> keyExtractor)`

🗣️ **入参解释**：`public static <K, T> Map<K, Long> countBy(待分组集合, key提取函数)`

📤 **返回值解释**：`Map<K, Long>`，key 到该组元素个数，不为 `null`

💡 **边界口径**：
- 计数类型是 `Long`，key 顺序同样是首次出现顺序
- 空值口径与 `groupBy` 一致：`null` 键算一组，元素为 `null` 时提取器要自己兜住
- 返回的 Map 可继续 `put`，不是只读视图
- 集合或提取器传 `null` 抛 `IllegalArgumentException`

🧪 **方法示例**：
- `countBy(orders, Order::shop)` 拿到 `{望京店=3, 国贸店=2, 西单店=1}`
- `countBy(tie, Order::shop)` 的结果再 `put("新店", 0L)` 拿到 `{望京店=2, 国贸店=1, 新店=0}`
- `countBy(orders, null)` 抛 `IllegalArgumentException: key提取函数不能为null`

---

🔢 **方法序号**：3

🎯 **方法用途**：
- 把每个 key 下的某个数值字段加总成「key 到合计」
- 分组求和一行拿到，不用自己开 Map 写循环累加

🧩 **方法定义**：`public static <K, T> Map<K, Double> sumBy(Collection<? extends T> collection, Function<? super T, K> keyExtractor, ToDoubleFunction<? super T> mapper)`

🗣️ **入参解释**：`public static <K, T> Map<K, Double> sumBy(待分组集合, key提取函数, 数值提取函数)`

📤 **返回值解释**：`Map<K, Double>`，key 到该组数值之和，不为 `null`

💡 **边界口径**：
- 用 `double` 累加，适合计数、耗时、比率这类统计量
- 金额别用这个方法，浮点累加有舍入误差，要精确合计就用 `BigDecimal` 逐组累加
- 空集合得到 `{}`，不会抛异常
- 三个入参任传 `null` 抛 `IllegalArgumentException`

🧪 **方法示例**：
- `sumBy(orders, Order::shop, Order::amount)` 拿到 `{望京店=58.0, 国贸店=80.0, 西单店=99.0}`
- `sumBy(orders, Order::shop, null)` 抛 `IllegalArgumentException: 数值提取函数不能为null`

---

🔢 **方法序号**：4

🎯 **方法用途**：
- 把每个 key 下的某个数值字段平均成「key 到均值」
- 一趟遍历同时攒出「和」与「个数」，比先求和再单独数一遍少一次遍历

🧩 **方法定义**：`public static <K, T> Map<K, Double> averageBy(Collection<? extends T> collection, Function<? super T, K> keyExtractor, ToDoubleFunction<? super T> mapper)`

🗣️ **入参解释**：`public static <K, T> Map<K, Double> averageBy(待分组集合, key提取函数, 数值提取函数)`

📤 **返回值解释**：`Map<K, Double>`，key 到该组均值，不为 `null`

💡 **边界口径**：
- 均值 = 该组数值之和除以该组元素个数，同样是 `double`，金额类不适用
- 空集合得到 `{}`，没有 key 就不会发生除法
- 参数校验与 `sumBy` 相同，三个入参任传 `null` 抛 `IllegalArgumentException`

🧪 **方法示例**：
- `averageBy(orders, Order::shop, Order::amount)` 拿到 `{望京店=19.333333333333332, 国贸店=40.0, 西单店=99.0}`，望京店是 58.0 除以 3
- `averageBy(new ArrayList<>(), Order::shop, Order::amount)` 拿到 `{}`

---

🔢 **方法序号**：5

🎯 **方法用途**：
- 把每个 key 下最「大」的那条元素挑出来，得到「key 到组内最值」
- 组维度取最值不用先分组、再对每组跑一遍 `max`

🧩 **方法定义**：`public static <K, T> Map<K, T> maxBy(Collection<? extends T> collection, Function<? super T, K> keyExtractor, Comparator<? super T> comparator)`

🗣️ **入参解释**：`public static <K, T> Map<K, T> maxBy(待分组集合, key提取函数, 元素比较器)`

📤 **返回值解释**：`Map<K, T>`，key 到该组最大元素，值就是原元素本身

💡 **边界口径**：
- 比较结果为 0 时保留先出现的那个，并列时的结果是确定的
- 比较器比的是整条元素，按字段取最值就把比较器写成那个字段
- 某个 key 能进结果就说明它至少有一条元素，不会出现空值占位
- 三个入参任传 `null` 抛 `IllegalArgumentException`；元素为 `null` 时提取器和比较器都得兜住

🧪 **方法示例**：
- `maxBy(orders, Order::shop, Comparator.comparingDouble(Order::amount))` 拿到 `{望京店=Order[shop=望京店, sku=A1, amount=38.0], 国贸店=Order[shop=国贸店, sku=A2, amount=60.0], 西单店=Order[shop=西单店, sku=A1, amount=99.0]}`
- `maxBy(tie, Order::shop, Comparator.comparingDouble(Order::amount))` 拿到 `{望京店=Order[shop=望京店, sku=A1, amount=50.0], 国贸店=Order[shop=国贸店, sku=C3, amount=10.0]}`，望京店两单金额都是 50.0，留下的是先出现的 A1
- `maxBy(orders, Order::shop, null)` 抛 `IllegalArgumentException: 比较器不能为null`

---

🔢 **方法序号**：6

🎯 **方法用途**：
- 把每个 key 下最「小」的那条元素挑出来，得到「key 到组内最值」
- 与 `maxBy` 成对，同一份数据换最低价那一单只要换个方法名

🧩 **方法定义**：`public static <K, T> Map<K, T> minBy(Collection<? extends T> collection, Function<? super T, K> keyExtractor, Comparator<? super T> comparator)`

🗣️ **入参解释**：`public static <K, T> Map<K, T> minBy(待分组集合, key提取函数, 元素比较器)`

📤 **返回值解释**：`Map<K, T>`，key 到该组最小元素，值就是原元素本身

💡 **边界口径**：
- 并列时同样保留先出现的元素
- 「最小」是比较器意义下的最小，比较器反过来写就反过来取
- 参数校验与 `maxBy` 一致，三个入参任传 `null` 抛 `IllegalArgumentException`

🧪 **方法示例**：
- `minBy(orders, Order::shop, Comparator.comparingDouble(Order::amount))` 拿到 `{望京店=Order[shop=望京店, sku=A1, amount=7.5], 国贸店=Order[shop=国贸店, sku=C3, amount=20.0], 西单店=Order[shop=西单店, sku=A1, amount=99.0]}`，望京店三单里取到 7.5 那单
- `minBy(tie, Order::shop, Comparator.comparingDouble(Order::amount))` 拿到 `{望京店=Order[shop=望京店, sku=A1, amount=50.0], 国贸店=Order[shop=国贸店, sku=C3, amount=10.0]}`，金额并列的望京店仍是先出现的 A1

---

🔢 **方法序号**：7

🎯 **方法用途**：
- 把一个集合按 key 收成「key 到一条元素」的 Map，元素自己就是值
- 重复 key 时留后出现的那条，取「每个门店最后一单」这类口径一步到位

🧩 **方法定义**：`public static <K, T> Map<K, T> toMap(Collection<? extends T> collection, Function<? super T, K> keyExtractor)`

🗣️ **入参解释**：`public static <K, T> Map<K, T> toMap(待转换集合, key提取函数)`

📤 **返回值解释**：`Map<K, T>`，key 到元素本身，重复 key 时是后写入的那条

💡 **边界口径**：
- 重复 key 保留后出现的元素，前一条被直接覆盖、不抛异常
- `null` 键照样能当一个正常的 key 用
- 集合或提取器传 `null` 抛 `IllegalArgumentException`，消息是「待转换集合不能为null」

🧪 **方法示例**：
- `toMap(orders, Order::shop)` 拿到 `{望京店=Order[shop=望京店, sku=A1, amount=7.5], 国贸店=Order[shop=国贸店, sku=C3, amount=20.0], 西单店=Order[shop=西单店, sku=A1, amount=99.0]}`，望京店三单里留下的是最后那单 7.5
- `toMap(rows, Order::shop)` 拿到 `{null=Order[shop=null, sku=A1, amount=1.0], 望京店=Order[shop=望京店, sku=B2, amount=2.0]}`，`null` 成了一个正常键

---

🔢 **方法序号**：8

🎯 **方法用途**：
- 把 `countBy` 出来的计数 Map 转成按笔数降序的 key 榜单
- 排行、TopN 这类「按次数看谁多」直接拿到排好序的 key 列表

🧩 **方法定义**：`public static <K> List<K> sortKeysByCountDesc(Map<K, Long> countMap)`

🗣️ **入参解释**：`public static <K> List<K> sortKeysByCountDesc(计数Map)`

📤 **返回值解释**：`List<K>`，按计数值降序的可变 key 列表

💡 **边界口径**：
- 排序稳定：计数相同的 key 维持原 Map 的迭代顺序，谁先出现谁在前
- 某个计数值为 `null` 时抛 `NullPointerException`，这是计数 Map 被外部写坏的情况，不伪装成 0
- 空 Map 得到空列表；传入的 Map 不必一定来自 `countBy`

🧪 **方法示例**：
- `sortKeysByCountDesc(countBy(orders, Order::shop))` 拿到 `[望京店, 国贸店, 西单店]`
- `sortKeysByCountDesc(counts)` 拿到 `[乙, 丁, 甲, 丙]`，`counts` 里甲和丙都是 2、乙和丁都是 5，同计数的保持原顺序
- `sortKeysByCountDesc(brokenCounts)` 抛 `NullPointerException`，其中一条计数值是 `null`
- `sortKeysByCountDesc(new LinkedHashMap<>())` 拿到 `[]`

---

🔢 **方法序号**：9

🎯 **方法用途**：
- 从分组结果里安全地取出一组，拿到的永远是列表而不是 `null`
- 不用再写 `getOrDefault(key, new ArrayList<>())`，也不会误改到原分组

🧩 **方法定义**：`public static <K, T> List<T> getGroup(Map<K, List<T>> grouped, K key)`

🗣️ **入参解释**：`public static <K, T> List<T> getGroup(分组Map, 要取的key)`

📤 **返回值解释**：`List<T>`，该组的不可变视图

💡 **边界口径**：
- 三种情况表现一致，都返回不可变空列表：① key 不存在；② key 存在但组值是 `null`；③ 传进来的 `key` 本身是 `null`
- 返回的列表加不进东西，`add` 抛 `UnsupportedOperationException`，要改分组内容就从 Map 里自己取
- 分组 Map 传 `null` 抛 `IllegalArgumentException: 分组Map不能为null`

🧪 **方法示例**：
- `getGroup(grouped, "望京店")` 拿到 `[Order[shop=望京店, sku=A1, amount=38.0], Order[shop=望京店, sku=B7, amount=12.5], Order[shop=望京店, sku=A1, amount=7.5]]`
- `getGroup(grouped, "未开业店")` 拿到 `[]`，key 不存在也不抛异常
- `getGroup(grouped, null)` 拿到 `[]`，与 key 不存在是同一种表现
- 对拿到的列表调 `add(...)` 抛 `UnsupportedOperationException`，`getMessage()` 是 `null`

## 四、工具类源码（可直接复制）

📦 见评论区



一批明细拿回来就按指定键分组，顺手计数、求和、算均值、取每组最大最小、把重复键压成单值、按笔数出榜单，不用再手写 Stream 收集器和临时累加。

不用手写Stream收集器：Java分组聚合工具类整理

编程语言

后端

一个JDK17+集合分组统计工具类，提供groupBy、countBy、sumBy、averageBy、maxBy、minBy、toMap、sortKeysByCountDesc、getGroup九种方法，直接替代手写Stream收集器，支持null键与null元素，含完整源码与调用示例。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

不用手写Stream收集器：Java分组聚合工具类整理-腾讯云开发者社区-腾讯云

不用手写Stream收集器：Java分组聚合工具类整理

不用手写Stream收集器：Java分组聚合工具类整理

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐