如何编写Java代码实现基于共享值聚合元素并提取首尾属性的教学案例？

本文共计2795个文字，预计阅读时间需要12分钟。

在数据处理和分析中，根据某个共同属性对数据执行分组和聚合是一项非常常见的操作。例如，我们可能需要从一系列事件记录中，按照项目id聚集相关事件，并计算每个项目的总持续时长，或者找到最早和最晚的时间点。

问题场景：实体对象按组聚合

假设我们有一个 Entities 列表，每个 Entities 对象包含一个开始日期（start_dt）、一个结束日期（stop_dt）和一个组号（groupNum）。具有相同 groupNum 的实体属于同一个逻辑组。我们的目标是聚合这些实体，对于每个组，我们希望得到一个代表该组的新实体，其 start_dt 是该组中所有实体的最早开始日期，而 stop_dt 则是该组中所有实体的最晚结束日期。

以下是原始数据示例：

Start	Stop	GroupNum
2018-11-13	2019-01-13	1
2019-01-14	2019-03-06	1
2019-03-07	2019-11-18	1
2020-08-23	2020-08-23	2
2021-11-19	2022-12-23	2

期望的聚合结果如下：

Start	Stop	GroupNum
2018-11-13	2019-11-18	1
2020-08-23	2022-12-23	2

解决方案：利用 Java Stream API 进行高效聚合

Java Stream API 提供了 Collectors.groupingBy 方法，可以非常方便地将数据流按指定属性分组。结合 map 操作，我们可以进一步处理每个分组，以提取所需的聚合信息。

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

完整的示例代码

首先，我们需要定义 Entities 类，并包含必要的字段、构造函数、getter 方法以及 toString 方法，以便于创建和打印对象。为了方便示例，我们还添加了日期字符串解析的构造函数。

import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Objects; import java.util.stream.Collectors; public class EntityAggregator { // 定义Entities类 public static class Entities { private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd"); private Date start_dt; private Date stop_dt; private int groupNum; // 构造函数：接受Date对象 public Entities(Date start_dt, Date stop_dt, int groupNum) { this.start_dt = start_dt; this.stop_dt = stop_dt; this.groupNum = groupNum; } // 构造函数：接受日期字符串，并进行解析 public Entities(String start_dt_str, String stop_dt_str, int groupNum) throws ParseException { this.start_dt = DATE_FORMAT.parse(start_dt_str); this.stop_dt = DATE_FORMAT.parse(stop_dt_str); this.groupNum = groupNum; } // Getter 方法 public Date getStart_dt() { return start_dt; } public Date getStop_dt() { return stop_dt; } public int getGroupNum() { return groupNum; } // toString 方法，便于打印 @Override public String toString() { return "Entities [start_dt=" + DATE_FORMAT.format(start_dt) + ", stop_dt=" + DATE_FORMAT.format(stop_dt) + ", groupNum=" + groupNum + "]"; } // 重写 equals 和 hashCode 方法（可选，但推荐） @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Entities entities = (Entities) o; return groupNum == entities.groupNum && Objects.equals(start_dt, entities.start_dt) && Objects.equals(stop_dt, entities.stop_dt); } @Override public int hashCode() { return Objects.hash(start_dt, stop_dt, groupNum); } } public static void main(String[] args) throws ParseException { // 准备原始数据 List<Entities> baseList = new ArrayList<>(); baseList.add(new Entities("2018-11-13", "2019-01-13", 1)); baseList.add(new Entities("2019-01-14", "2019-03-06", 1)); baseList.add(new Entities("2019-03-07", "2019-11-18", 1)); baseList.add(new Entities("2020-08-23", "2020-08-23", 2)); baseList.add(new Entities("2021-11-19", "2022-12-23", 2)); // 使用 Stream API 进行聚合 List<Entities> result = baseList.stream() // 1. 按 groupNum 分组 .collect(Collectors.groupingBy(Entities::getGroupNum)) // 2. 将 Map 的 EntrySet 转换为 Stream .entrySet().stream() // 3. 对每个分组进行处理，生成新的 Entities 对象 .map(entry -> { List<Entities> groupEntities = entry.getValue(); // 获取组内第一个元素的 start_dt (假设数据已按日期排序) Date firstStartDate = groupEntities.get(0).getStart_dt(); // 获取组内最后一个元素的 stop_dt (假设数据已按日期排序) Date lastStopDate = groupEntities.get(groupEntities.size() - 1).getStop_dt(); // 获取组号 int groupNum = entry.getKey(); // 创建新的聚合实体 return new Entities(firstStartDate, lastStopDate, groupNum); }) // 4. 将结果收集为 List .toList(); // Java 16+ 使用 toList(), 之前版本使用 Collectors.toList() // 打印聚合结果 result.forEach(System.out::println); } }

代码解析

1. baseList.stream(): 将原始 List<Entities> 转换为一个 Stream，以便使用 Stream API 进行链式操作。
2. .collect(Collectors.groupingBy(Entities::getGroupNum)): 这是聚合的核心步骤。
   • Collectors.groupingBy() 是一个收集器，用于将 Stream 中的元素按照指定的分类函数进行分组。
   • Entities::getGroupNum 是一个方法引用，它作为分类函数，告诉 groupingBy 应该根据 Entities 对象的 groupNum 属性进行分组。
   • 此操作的结果是一个 Map<Integer, List<Entities>>，其中键是 groupNum，值是所有具有该 groupNum 的 Entities 对象的列表。
3. .entrySet().stream(): 上一步得到了一个 Map，为了继续使用 Stream API 处理每个分组，我们将其 entrySet()（即 Map.Entry 对象的集合）转换为一个新的 Stream。每个 Map.Entry 包含一个 groupNum（作为键）和对应的 List<Entities>（作为值）。
4. .map(entry -> { ... }): 这一步对 Stream 中的每个 Map.Entry（即每个分组）进行转换，生成一个新的 Entities 对象。
   • entry.getValue() 获取当前分组的所有 Entities 对象列表。
   • groupEntities.get(0).getStart_dt(): 提取该组中第一个元素的 start_dt。这里假设输入数据在每个组内已经按日期升序排列，因此第一个元素的 start_dt 就是该组的最早开始日期。
   • groupEntities.get(groupEntities.size() - 1).getStop_dt(): 提取该组中最后一个元素的 stop_dt。同样假设数据已排序，因此最后一个元素的 stop_dt 就是该组的最晚结束日期。
   • entry.getKey(): 获取当前分组的 groupNum。
   • 最后，使用这些聚合后的日期和组号创建一个新的 Entities 对象。
5. .toList(): 将 map 操作产生的新 Entities 对象收集到一个新的 List 中。这是 Java 16+ 的便捷方法，等同于 collect(Collectors.toList())。

运行结果

执行上述 main 方法，将得到如下输出：

Entities [start_dt=2018-11-13, stop_dt=2019-11-18, groupNum=1] Entities [start_dt=2020-08-23, stop_dt=2022-12-23, groupNum=2]

这与我们期望的聚合结果完全一致。

注意事项与优化

1. 日期处理：java.util.Date 与 java.time

示例中使用了 java.util.Date 和 java.text.SimpleDateFormat。在现代 Java 开发中（Java 8 及更高版本），强烈推荐使用 java.time 包中的日期时间 API，如 LocalDate、LocalDateTime 等。它们提供了更好的可读性、不可变性、线程安全性以及更强大的功能。

如果使用 java.time，Entities 类可以修改为：

import java.time.LocalDate; import java.time.format.DateTimeFormatter; import java.util.Objects; public static class Entities { private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd"); private LocalDate start_dt; private LocalDate stop_dt; private int groupNum; public Entities(LocalDate start_dt, LocalDate stop_dt, int groupNum) { this.start_dt = start_dt; this.stop_dt = stop_dt; this.groupNum = groupNum; } public Entities(String start_dt_str, String stop_dt_str, int groupNum) { this.start_dt = LocalDate.parse(start_dt_str, DATE_FORMATTER); this.stop_dt = LocalDate.parse(stop_dt_str, DATE_FORMATTER); this.groupNum = groupNum; } // Getters public LocalDate getStart_dt() { return start_dt; } public LocalDate getStop_dt() { return stop_dt; } public int getGroupNum() { return groupNum; } @Override public String toString() { return "Entities [start_dt=" + start_dt.format(DATE_FORMATTER) + ", stop_dt=" + stop_dt.format(DATE_FORMATTER) + ", groupNum=" + groupNum + "]"; } // equals/hashCode 类似 }

相应的，在 main 方法中，比较日期时可以直接使用 LocalDate 的 compareTo 方法。

2. 健壮性考虑：输入数据未排序的情况

当前解决方案依赖于每个组内的 Entities 列表已经按日期排序的假设。如果原始 baseList 中的元素顺序是随机的，那么 groupEntities.get(0).getStart_dt() 和 groupEntities.get(groupEntities.size() - 1).getStop_dt() 将无法正确获取最早和最晚日期。

为了更健壮地处理这种情况，应该在 map 阶段明确地找到每个组内的最小 start_dt 和最大 stop_dt：

.map(entry -> { List<Entities> groupEntities = entry.getValue(); // 明确查找组内的最小开始日期 Date minStart = groupEntities.stream() .map(Entities::getStart_dt) .min(Date::compareTo) // 或 LocalDate::compareTo .orElse(null); // 处理空组的情况，这里不会发生 // 明确查找组内的最大结束日期 Date maxStop = groupEntities.stream() .map(Entities::getStop_dt) .max(Date::compareTo) // 或 LocalDate::compareTo .orElse(null); int groupNum = entry.getKey(); return new Entities(minStart, maxStop, groupNum); })

这种方式虽然代码量稍多，但确保了无论输入列表顺序如何，都能得到正确的结果。

3. 自定义聚合逻辑：Collectors.reducing 或 Collectors.collectingAndThen

对于更复杂的聚合逻辑，或者希望一步到位地完成分组和聚合，可以结合 groupingBy 的第二个参数，使用 Collectors.reducing 或 Collectors.collectingAndThen。

例如，使用 reducing 来找到每个组的最小 start_dt 和最大 stop_dt（这会更复杂一些，因为需要同时跟踪两个值，通常需要一个自定义的 BinaryOperator）：

// 假设Entities有一个合并方法来更新start/stop // 这种方式更适合单值聚合，对于同时聚合两个独立值，直接在map中处理可能更清晰。 // 或者定义一个更复杂的下游收集器 List<Entities> resultAdvanced = baseList.stream() .collect(Collectors.groupingBy(Entities::getGroupNum, Collectors.reducing( // 初始值：可以是一个默认实体，或者使用Optional // 更好的方式是使用 collectingAndThen + SummaryStatistics // 这里为了简化，我们直接在map中处理 (e1, e2) -> { Date newStart = e1.getStart_dt().before(e2.getStart_dt()) ? e1.getStart_dt() : e2.getStart_dt(); Date newStop = e1.getStop_dt().after(e2.getStop_dt()) ? e1.getStop_dt() : e2.getStop_dt(); return new Entities(newStart, newStop, e1.getGroupNum()); } ) )) .entrySet().stream() .map(entry -> entry.getValue().orElse(null)) // reducing 返回 Optional .filter(Objects::nonNull) .toList();

这种 reducing 的方式需要 Entities 类能够“合并”自身，并且处理 Optional。对于本例，groupingBy 后跟 map 的链式操作更为直观易懂。

总结

通过本教程，我们学习了如何利用 Java Stream API 的 Collectors.groupingBy 方法，结合 map 操作，高效地实现对对象列表的按属性分组聚合。这种模式在处理各种数据聚合需求时非常有用，能够写出简洁、富有表达力的代码。同时，我们也探讨了在处理日期类型和确保聚合逻辑健壮性方面需要