Java 8 Streams：实现多条件过滤、按月分组及计数统计

本文详细讲解如何利用java 8 streams api高效处理复杂数据聚合需求，包括多条件过滤、按日期月份分组以及对特定事件类型（如join/exit）进行计数统计。通过构建自定义分组键和链式stream操作，实现从原始数据结构到结构化统计结果的转换，并提供完整的代码示例和关键步骤解析。

1. 场景概述与数据模型

在日常开发中，我们经常需要对数据进行复杂的聚合操作，例如从一组人员事件记录中，统计每个月不同事件类型（如“入职”或“离职”）的总人数。本教程将以一个具体的Java场景为例，演示如何使用Java 8 Stream API实现这一目标。

假设我们有以下人员（Person）事件数据：

import java.time.LocalDate;

// 定义事件类型枚举
public enum State {
    JOIN, // 入职
    EXIT  // 离职
}

// Person类，存储人员事件信息
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, State event, LocalDate eventDate) {
        this.id = id;
        this.event = event;
        this.eventDate = eventDate;
    }

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

    // 可根据需要添加其他方法
}

我们的原始数据可能存储在一个Map>中，其中键是pId，值是该pId对应的Person事件列表。

最终我们希望得到如下形式的统计结果：

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

Month  Info Total Number
1        JOIN       2
1        EXIT       1
2        EXIT       1
3        JOIN       1

为了存储这个结果，我们定义一个数据传输对象（DTO）：

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 +
               '}';
    }
}

2. 构建自定义分组键

在进行分组统计时，我们需要一个能够唯一标识分组的键。在本例中，分组的依据是“月份”和“事件类型”。我们可以创建一个自定义类或Java 16引入的record来作为这个复合键。使用record是更简洁的选择：

// Java 16+ 使用 record 作为分组键
public record MonthState(int month, State info) {}

// 对于Java 8-15，你需要一个普通的类，并重写 equals() 和 hashCode() 方法
/*
public class MonthState {
    private int month;
    private 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);
    }
}
*/

record会自动生成构造函数、equals()、hashCode()和toString()方法，非常适合作为不可变的数据载体。

3. Stream API实现步骤详解

现在，我们将逐步构建Stream管道来完成数据聚合：

3.1 准备数据

首先，模拟一些原始数据：

AVCLabs

AI移除视频背景，100%自动和免费

下载

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class StreamAggregationDemo {

    public static void main(String[] args) {
        // 模拟原始数据
        Map> personListById = Map.of(
            "per1", List.of(new Person("per1", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per2", List.of(new Person("per2", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per3", List.of(
                new Person("per3", State.EXIT, LocalDate.of(2022, 1, 10)),
                new Person("per3", State.EXIT, LocalDate.of(2022, 2, 10))
            ),
            "per4", List.of(new Person("per4", State.JOIN, LocalDate.of(2022, 3, 10)))
        );

        // ... Stream 管道将在这里构建
    }
}

3.2 扁平化处理 (flatMap)

由于原始数据是一个Map>，我们需要将Map的值（List）扁平化成一个单一的Person对象流。

personListById.values().stream() // 获取 Map 中所有 List 的 Stream
    .flatMap(List::stream)      // 将每个 List 扁平化为 Person 对象的 Stream

3.3 过滤 (filter)

接下来，我们只关心JOIN和EXIT这两种事件类型。

.filter(person -> person.getEvent() == State.EXIT || person.getEvent() == State.JOIN)

3.4 分组与计数 (groupingBy & counting)

这是核心步骤，我们将使用Collectors.groupingBy()方法。它需要两个参数：

1. 分类函数 (Classifier function)：用于从流中的元素中提取分组键。这里我们使用p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent())来创建MonthState作为分组键。
2. 下游收集器 (Downstream collector)：用于对每个分组中的元素进行聚合。这里我们使用Collectors.counting()来统计每个分组中的元素数量。

.collect(Collectors.groupingBy(
    p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent()), // 分组键：月份和事件类型
    Collectors.counting() // 对每个分组中的元素进行计数
))

这一步将返回一个Map，其中键是MonthState对象，值是该组合下的Person数量。

3.5 转换结果 (entrySet().stream().map)

现在我们有了一个Map，需要将其转换回我们定义的List形式。

1. entrySet().stream()：将Map的Entry集合转换为一个Stream>。
2. map(e -> new DTO(e.getKey().month(), e.getKey().info(), (int) (long) e.getValue()))：将每个Map.Entry映射为一个DTO对象。注意，Collectors.counting()返回Long类型，需要强制转换为int。

.entrySet().stream() // 将 Map 转换为 Stream>
.map(e -> new DTO(e.getKey().month(), e.getKey().info(), (int) (long) e.getValue())) // 映射为 DTO

3.6 排序 (sorted)

为了使结果更具可读性，我们可以按月份对DTO列表进行排序。

.sorted(Comparator.comparing(DTO::getMonth)) // 按月份排序

3.7 收集结果 (toList)

最后，将Stream中的所有DTO对象收集到一个List中。

.toList(); // 收集为 List (Java 16+) 或 .collect(Collectors.toList()) (Java 8-15)

4. 完整代码示例

将上述所有步骤组合起来，得到完整的Stream管道：

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

// 定义事件类型枚举
enum State {
    JOIN, // 入职
    EXIT  // 离职
}

// Person类，存储人员事件信息
class Person {
    private String id;
    private State event; // 事件类型：JOIN 或 EXIT
    private LocalDate eventDate; // 事件日期

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

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

// 分组键
record MonthState(int month, State info) {}

// 结果DTO
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;
    }

    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 +
               '}';
    }
}

public class StreamAggregationDemo {

    public static void main(String[] args) {
        // 模拟原始数据
        Map> personListById = Map.of(
            "per1", List.of(new Person("per1", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per2", List.of(new Person("per2", State.JOIN, LocalDate.of(2022, 1, 10))),
            "per3", List.of(
                new Person("per3", State.EXIT, LocalDate.of(2022, 1, 10)),
                new Person("per3", State.EXIT, LocalDate.of(2022, 2, 10))
            ),
            "per4", List.of(new Person("per4", State.JOIN, LocalDate.of(2022, 3, 10)))
        );

        List result = personListById.values().stream()
            .flatMap(List::stream) // 扁平化 List
            .filter(person -> person.getEvent() == State.EXIT || person.getEvent() == State.JOIN) // 过滤事件类型
            .collect(Collectors.groupingBy(
                p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent()), // 按月份和事件类型分组
                Collectors.counting() // 统计每个分组的数量
            ))
            .entrySet().stream() // 将 Map 转换为 Stream
            .map(e -> new DTO(e.getKey().month(), e.getKey().info(), (int) (long) e.getValue())) // 映射为 DTO
            .sorted(Comparator.comparing(DTO::getMonth)) // 按月份排序
            .toList(); // 收集结果 (Java 16+ 的简写，Java 8-15 使用 .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}
        */
    }
}

5. 注意事项与总结

• 自定义分组键的重要性：当需要根据多个属性进行分组时，创建一个包含这些属性的自定义对象（如MonthState）作为分组键至关重要。对于Java 8-15，务必正确实现equals()和hashCode()方法；对于Java 16+，record是理想且简洁的选择。
• Stream操作的链式调用：Java Stream API通过链式调用（flatMap -> filter -> collect -> map -> sorted -> toList）实现了一种声明式的数据处理方式，代码可读性高，逻辑清晰。
• 下游收集器：Collectors.groupingBy()的第二个参数是一个下游收集器，它决定了对每个分组内的元素如何进行聚合。Collectors.counting()用于计数，Collectors.summingInt()、Collectors.averagingDouble()等用于求和、求平均，Collectors.mapping()用于进一步转换等。
• 类型转换：Collectors.counting()返回Long类型，如果目标DTO字段是int，需要进行显式类型转换(int) (long) e.getValue()。
• 性能考量：对于非常大的数据集，Stream API的性能通常表现良好，尤其是在可以并行化的情况下。然而，复杂的Stream管道也可能带来一定的开销，应根据实际情况进行性能测试和优化。

通过本教程，您应该能够掌握如何利用Java 8 Stream API进行多条件过滤、按复合键分组以及进行计数统计，从而高效地处理复杂的数据聚合任务。