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

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 则是该组中所有实体的最晚结束日期。

以下是原始数据示例：

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);
    }
}

登录后复制

代码解析

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

千图设计室AI海报

千图网旗下的智能海报在线设计平台

227

查看详情

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

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