Java 中按共享值聚合元素并提取首尾属性的教程

本教程详细介绍了如何使用 Java Stream API 高效地将列表中的实体对象按共享的组号（GroupNum）进行聚合。通过 Collectors.groupingBy 对数据进行分组，然后从每个组中提取最早的开始日期（Start Date）和最晚的结束日期（Stop Date），最终生成一个汇总后的实体列表。文章提供了完整的代码示例、详细的代码解析及注意事项，旨在帮助开发者掌握基于特定属性进行数据聚合的技巧。

引言：数据聚合的常见需求

在数据处理和分析中，根据某个共同属性对数据进行分组和聚合是一项非常常见的操作。例如，我们可能需要从一系列事件记录中，按项目id聚合所有相关事件，并计算每个项目的总持续时间，或者找到最早的开始时间和最晚的结束时间。java 8 引入的 stream api 极大地简化了这类操作，提供了声明式和高效的数据处理方式。

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

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

以下是原始数据示例：

2018-11-132019-01-1312019-01-142019-03-0612019-03-072019-11-1812020-08-232020-08-2322021-11-192022-12-232

期望的聚合结果如下：

2018-11-132019-11-1812020-08-232022-12-232

解决方案：利用 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 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 result = baseList.stream()            // 1. 按 groupNum 分组            .collect(Collectors.groupingBy(Entities::getGroupNum))            // 2. 将 Map 的 EntrySet 转换为 Stream            .entrySet().stream()            // 3. 对每个分组进行处理，生成新的 Entities 对象            .map(entry -> {                List 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);    }}

代码解析

baseList.stream(): 将原始 List 转换为一个 Stream，以便使用 Stream API 进行链式操作。.collect(Collectors.groupingBy(Entities::getGroupNum)): 这是聚合的核心步骤。Collectors.groupingBy() 是一个收集器，用于将 Stream 中的元素按照指定的分类函数进行分组。Entities::getGroupNum 是一个方法引用，它作为分类函数，告诉 groupingBy 应该根据 Entities 对象的 groupNum 属性进行分组。此操作的结果是一个 Map<Integer, List>，其中键是 groupNum，值是所有具有该 groupNum 的 Entities 对象的列表。.entrySet().stream(): 上一步得到了一个 Map，为了继续使用 Stream API 处理每个分组，我们将其 entrySet()（即 Map.Entry 对象的集合）转换为一个新的 Stream。每个 Map.Entry 包含一个 groupNum（作为键）和对应的 List（作为值）。.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 对象。.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 类可以修改为：

v0.dev

Vercel推出的AI生成式UI工具，通过文本描述生成UI组件代码

261 查看详情

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 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 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 操作，高效地实现对对象列表的按属性分组聚合。这种模式在处理各种数据聚合需求时非常有用，能够写出简洁、富有表达力的代码。同时，我们也探讨了在处理日期类型和确保聚合逻辑健壮性方面需要

以上就是Java 中按共享值聚合元素并提取首尾属性的教程的详细内容，更多请关注创想鸟其它相关文章！