高效利用Java Stream API：多条件过滤、按月分组与聚合求和

import java.time.LocalDate;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Comparator;
import java.util.stream.Collectors;

// 事件类型枚举
public enum State {
    JOIN,
    EXIT;
}

// 原始数据模型
public class Person {
    private String id;
    private String name;
    private String surname;
    private State event; // JOIN, EXIT
    private Object value; // 示例中未使用，可根据实际需求调整
    private LocalDate eventDate;

    public Person(String id, String name, String surname, State event, LocalDate eventDate) {
        this.id = id;
        this.name = name;
        this.surname = surname;
        this.event = event;
        this.eventDate = eventDate;
    }

    // Getters
    public String getId() { return id; }
    public State getEvent() { return event; }
    public LocalDate getEventDate() { return eventDate; }

    @Override
    public String toString() {
        return "Person{" + "id='" + id + '\'' + ", event=" + event + ", eventDate=" + eventDate + '}';
    }
}

// 最终输出数据模型
public class DTO {
    private int month;
    private State info;
    private int totalEmployees;

    public DTO(int month, State info, int totalEmployees) {
        this.month = month;
        this.info = info;
        this.totalEmployees = totalEmployees;
    }

    // Getters
    public int getMonth() { return month; }
    public State getInfo() { return info; }
    public int getTotalEmployees() { return totalEmployees; }

    @Override
    public String toString() {
        return "DTO{" + "month=" + month + ", info=" + info + ", totalEmployees=" + totalEmployees + '}';
    }
}

// 用于分组的复合键（Java 16+ 可使用 record）
public record MonthState(int month, State info) {}

// 对于Java 8-15，可以使用普通类实现复合键，需要重写equals()和hashCode()
/*
public class MonthState {
    private final int month;
    private final State info;

    public MonthState(int month, State info) {
        this.month = month;
        this.info = info;
    }

    public int getMonth() { return month; }
    public State getInfo() { return info; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        MonthState that = (MonthState) o;
        return month == that.month && info == that.info;
    }

    @Override
    public int hashCode() {
        return Objects.hash(month, info);
    }
}
*/

public class StreamProcessingExample {

    public static void main(String[] args) {
        // 示例数据初始化
        Map<String, List<Person>> personListById = Map.of(
            "per1", List.of(new Person("per1", "Alice", "Smith", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per2", List.of(new Person("per2", "Bob", "Johnson", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per3", List.of(
                new Person("per3", "Charlie", "Brown", State.EXIT, LocalDate.of(2022, 1, 10)),
                new Person("per3", "Charlie", "Brown", State.EXIT, LocalDate.of(2022, 2, 10))
            ),
            "per4", List.of(new Person("per4", "David", "Miller", State.JOIN, LocalDate.of(2022, 3, 10)))
        );

        List<DTO> result = personListById.values().stream()
            // 1. 扁平化：将 Map 的值（List<Person>）扁平化为 Person 对象的流
            .flatMap(List::stream)
            // 2. 过滤：只保留 JOIN 或 EXIT 类型的事件
            .filter(per -> per.getEvent() == State.EXIT || per.getEvent() == State.JOIN)
            // 3. 分组与计数：
            //    - 使用 MonthState 作为复合键，根据事件日期月份和事件类型进行分组
            //    - 使用 Collectors.counting() 统计每个分组的元素数量
            .collect(Collectors.groupingBy(
                p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent()),
                Collectors.counting()
            ))
            // 4. 将 Map.Entry 流转换为 DTO 对象流
            .entrySet().stream()
            .map(e -> new DTO(e.getKey().month(), e.getKey().info(), (int) (long) e.getValue()))
            // 5. 排序：根据月份对 DTO 列表进行排序
            .sorted(Comparator.comparing(DTO::getMonth))
            // 6. 收集：将结果收集为 List<DTO>
            .toList(); // 或者 .collect(Collectors.toList());

        // 打印结果
        result.forEach(System.out::println);
        /* 预期输出:
        DTO{month=1, info=JOIN, totalEmployees=2}
        DTO{month=1, info=EXIT, totalEmployees=1}
        DTO{month=2, info=EXIT, totalEmployees=1}
        DTO{month=3, info=JOIN, totalEmployees=1}
        */
    }
}