当前位置：首页 > 文章列表 > 文章 > java教程 > JavaStream多条件过滤与月统计技巧

JavaStream多条件过滤与月统计技巧

2025-11-01 13:09:41 0浏览收藏

今天golang学习网给大家带来了《Java Stream多条件过滤与按月统计方法》，其中涉及到的知识点包括等等，无论你是小白还是老手，都适合看一看哦~有好的建议也欢迎大家在评论留言，若是看完有所收获，也希望大家能多多点赞支持呀！一起加油学习~

Java Stream API：实现多条件过滤、按月分组及聚合计数

本文深入探讨如何利用Java Stream API高效处理复杂数据聚合需求，包括对集合进行多条件过滤、根据日期字段的月份进行分组，并对每个分组进行计数。通过构建一个清晰的Stream管道，结合`flatMap`、`filter`、`groupingBy`与自定义分组键，最终将原始数据转换为结构化的统计结果，并提供完整示例代码和最佳实践。

Java Stream API 实现复杂数据聚合：过滤、分组与计数

在现代Java应用开发中，数据处理和聚合是常见的任务。Java 8引入的Stream API提供了一种声明式、函数式的方式来处理集合数据，极大地简化了代码并提高了可读性。本文将详细介绍如何使用Stream API实现多条件过滤、按日期字段的月份进行分组，并对每个分组中的元素进行计数。

1. 数据模型定义

首先，我们需要定义用于存储和传输数据的类。假设我们有一个Person类，包含人员ID、姓名、事件类型（Statement）和事件日期等信息。我们还定义了用于表示聚合结果的DTO（Data Transfer Object），以及作为分组键的辅助类MonthState。

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

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

// 原始Person数据模型
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; }

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

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

    // 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)
// 对于Java 8-15，需要手动实现 equals() 和 hashCode()
record MonthState(int month, State info) {}

/*
// Java 8-15 版本的 MonthState 类
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);
    }
}
*/

2. 构建Stream管道进行数据聚合

我们的目标是从一个Map>结构（其中键是pId，值是该pId对应的Person列表）中，提取出所有Person对象，然后：

过滤：只保留事件类型为JOIN或EXIT的Person。
分组：根据事件日期的月份和事件类型（State）进行分组。
计数：统计每个分组中Person对象的数量。
映射：将分组结果转换为DTO对象。
排序：按月份对DTO列表进行排序。

下面是实现这一目标的Stream管道代码：

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

public class StreamAggregationTutorial {

    public static void main(String[] args) {
        // 模拟原始数据
        Map<String, List<Person>> 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))),
            "per5", List.of(new Person("per5", State.OTHER, LocalDate.of(2022, 4, 10))) // 应该被过滤掉
        );

        List<DTO> result = personListById.values().stream()
            // 1. 扁平化处理：将Map中List<Person>的值转换为单个Person对象的Stream
            .flatMap(List::stream)
            // 2. 多条件过滤：只保留事件类型为JOIN或EXIT的Person
            .filter(person -> person.getEvent() == State.JOIN || person.getEvent() == State.EXIT)
            // 3. 分组与计数：
            //    - 使用Collectors.groupingBy()进行分组。
            //    - 分组键是一个MonthState对象，结合了月份和事件类型。
            //    - 下游收集器Collectors.counting()用于统计每个分组的元素数量。
            .collect(Collectors.groupingBy(
                p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent()),
                Collectors.counting()
            ))
            // 4. 将Map的entrySet转换为Stream，以便进行后续的映射操作
            .entrySet().stream()
            // 5. 映射：将Map.Entry<MonthState, Long>转换为DTO对象
            //    - e.getKey()获取MonthState对象（分组键）
            //    - e.getValue()获取计数结果（Long类型，需要转换为int）
            .map(e -> new DTO(e.getKey().month(), e.getKey().info(), e.getValue().intValue()))
            // 6. 排序：根据DTO的月份进行排序
            .sorted(Comparator.comparing(DTO::getMonth))
            // 7. 收集：将Stream中的DTO对象收集到List中
            .toList(); // Java 16+，等同于 .collect(Collectors.toList())

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

3. 代码解析与注意事项

3.1 扁平化 (flatMap)

原始数据结构是Map>，我们需要处理的是List中的每个Person对象。personListById.values().stream()会得到一个Stream>。flatMap(List::stream)的作用是将这个Stream>扁平化为一个Stream，使得后续操作可以直接作用于单个Person对象。

3.2 多条件过滤 (filter)

filter(person -> person.getEvent() == State.JOIN || person.getEvent() == State.EXIT)用于筛选出符合特定条件的Person对象。这里的条件是事件类型必须是JOIN或EXIT。filter操作是中间操作，它会根据给定的Predicate（一个返回布尔值的函数）筛选元素。

3.3 分组与计数 (groupingBy & counting)

这是聚合的核心部分：

Collectors.groupingBy(keyMapper, downstreamCollector)：这是一个强大的收集器，用于将Stream中的元素分组到一个Map中。
- keyMapper：p -> new MonthState(p.getEventDate().getMonthValue(), p.getEvent()) 定义了如何从每个Person对象中提取分组键。我们创建了一个MonthState实例，它结合了事件日期的月份和事件类型，作为复合键。
- downstreamCollector：Collectors.counting() 是一个下游收集器，它作用于每个分组内部的元素。对于每个MonthState分组，counting()会统计该分组中Person对象的数量。
MonthState作为分组键：为了让groupingBy正确工作，作为分组键的类（MonthState）必须正确实现equals()和hashCode()方法。如果使用Java 16+的record类型，编译器会自动生成这些方法，确保基于值进行比较和哈希。如果使用普通的class，则需要手动实现它们。

3.4 结果映射 (map)

collect操作返回的是一个Map。我们需要将其转换为List。

entrySet().stream()：将Map的键值对集合转换为Stream>。
map(e -> new DTO(e.getKey().month(), e.getKey().info(), e.getValue().intValue()))：对每个Map.Entry进行映射。e.getKey()获取到MonthState对象，从中提取月份和事件类型。e.getValue()获取到计数结果（Long类型），通过intValue()转换为int。

3.5 排序 (sorted)

sorted(Comparator.comparing(DTO::getMonth)) 用于对最终的DTO列表按月份进行升序排序，使输出结果更具可读性。

3.6 最终收集 (toList)

toList() (Java 16+) 或 collect(Collectors.toList()) (Java 8+) 将Stream中的所有元素收集到一个List中。

4. 总结

通过Java Stream API，我们可以用简洁、声明式的方式完成复杂的数据聚合任务。本教程展示了如何结合flatMap进行扁平化、filter进行多条件过滤、groupingBy与自定义复合键（如record类型）进行分组，以及counting进行聚合计数。这种链式操作不仅提高了代码的可读性，也使得数据处理逻辑更加清晰。熟练掌握Stream API是现代Java开发中不可或缺的技能。

好了，本文到此结束，带大家了解了《JavaStream多条件过滤与月统计技巧》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！