Java中基于共享值聚合对象并提取首尾日期教程

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Objects;

public class Entities {
    private final LocalDate start_dt;
    private final LocalDate stop_dt;
    private int groupNum;

    // 日期格式化器，用于从字符串解析日期
    private static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd");

    public Entities(String start_dt_str, String stop_dt_str, int groupNum) {
        this.start_dt = LocalDate.parse(start_dt_str, FORMATTER);
        this.stop_dt = LocalDate.parse(stop_dt_str, FORMATTER);
        this.groupNum = groupNum;
    }

    public Entities(LocalDate start_dt, LocalDate stop_dt, int groupNum) {
        this.start_dt = start_dt;
        this.stop_dt = stop_dt;
        this.groupNum = groupNum;
    }

    // Getters
    public LocalDate getStart_dt() {
        return start_dt;
    }

    public LocalDate getStop_dt() {
        return stop_dt;
    }

    public int getGroupNum() {
        return groupNum;
    }

    // toString 方法方便打印输出
    @Override
    public String toString() {
        return "Entities [start_dt=" + start_dt.format(FORMATTER) + 
               ", stop_dt=" + stop_dt.format(FORMATTER) + 
               ", groupNum=" + groupNum + "]";
    }

    // hashCode 和 equals 方法，如果需要将Entities对象作为Map的键，或者进行集合比较
    @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);
    }
}

import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class EntityAggregator {

    public static void main(String[] args) {
        // 准备原始数据
        List<Entities> baseList = new ArrayList<>();
        try {
            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));
        } catch (DateTimeParseException e) {
            System.err.println("日期解析错误: " + e.getMessage());
            return;
        }

        // 执行聚合操作
        List<Entities> result = aggregateEntitiesByGroup(baseList);

        // 打印结果
        result.forEach(System.out::println);
    }

    /**
     * 根据groupNum聚合实体，提取每个组的最早开始日期和最晚结束日期。
     *
     * @param entitiesList 原始实体列表
     * @return 聚合后的实体列表
     */
    public static List<Entities> aggregateEntitiesByGroup(List<Entities> entitiesList) {
        if (entitiesList == null || entitiesList.isEmpty()) {
            return new ArrayList<>();
        }

        return entitiesList.stream()
            // 1. 按 groupNum 分组，得到 Map<Integer, List<Entities>>
            .collect(Collectors.groupingBy(Entities::getGroupNum))
            // 2. 将 Map 的 EntrySet 转换为 Stream
            .entrySet().stream()
            // 3. 对每个 Entry (即每个组) 进行映射，生成一个新的 Entities 对象
            .map(entry -> {
                Integer groupNum = entry.getKey(); // 获取组号
                List<Entities> groupEntities = entry.getValue(); // 获取该组的所有实体

                // 确保组内实体不为空，虽然 groupingBy 保证了这一点
                if (groupEntities.isEmpty()) {
                    return null; // 或者抛出异常，取决于业务需求
                }

                // 找到组内最早的 start_dt
                LocalDate firstStartDate = groupEntities.stream()
                                                      .map(Entities::getStart_dt)
                                                      .min(LocalDate::compareTo)
                                                      .orElse(null); // 如果列表为空，则返回null

                // 找到组内最晚的 stop_dt
                LocalDate lastStopDate = groupEntities.stream()
                                                     .map(Entities::getStop_dt)
                                                     .max(LocalDate::compareTo)
                                                     .orElse(null); // 如果列表为空，则返回null

                // 创建并返回新的聚合实体
                return new Entities(firstStartDate, lastStopDate, groupNum);
            })
            // 4. 过滤掉可能产生的null值（如果上述逻辑中返回了null）
            .filter(Objects::nonNull)
            // 5. 将结果收集为 List
            .collect(Collectors.toList());
    }
}

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]