登录注册

当前位置：首页 > 文章列表 > 文章 > java教程 > Java8Stream分组聚合教程：对象处理详解

Java8Stream分组聚合教程：对象处理详解

2025-10-31 17:06:38 0浏览 收藏

本教程深入解析 Java 8 Stream API 在处理自定义对象列表时的分组聚合技巧，重点解决多属性分组和数值字段聚合求和的难题。针对具有相同名称、年龄和城市的学生数据，我们通过巧妙运用 `Collectors.groupingBy` 结合自定义复合键（如 `NameAgeCity` 类）以及聚合容器 `AggregatedValues`，实现了高效且灵活的数据处理。详细介绍了如何使用 `Collector.of` 自定义聚合逻辑，将相同分组的学生薪资和奖金进行累加，最终生成聚合后的全新列表。无论您是初学者还是有经验的 Java 开发者，本教程都将为您提供实用的代码示例和深入的原理讲解，助您轻松掌握 Java 8 Stream 的高级用法。

Java 8 Stream 多属性分组与聚合：自定义对象列表处理教程

本教程详细介绍了如何利用 Java 8 Stream API，对自定义对象列表进行多属性分组，并对指定数值字段进行聚合求和。通过引入自定义复合键类和聚合容器，结合 `Collectors.groupingBy` 和 `Collector.of`，实现了高效、灵活的数据处理，将具有相同名称、年龄和城市的学生数据合并，并累加其薪资和奖金，最终生成聚合后的新列表。

引言：Java 8 Stream 的多维聚合挑战

在数据处理中，我们经常需要对列表中的对象进行分组，并根据分组结果对某些属性进行聚合计算。例如，在一个学生列表中，我们可能需要根据学生的姓名、年龄和城市进行分组，然后统计每个分组的总薪资和总奖金。Java 8 引入的 Stream API 提供了强大的功能来处理这类问题，但对于涉及多属性分组和自定义聚合逻辑的场景，需要巧妙地结合 Collectors 来实现。

问题分析与原始尝试的局限

假设我们有一个 Student 类，包含姓名、年龄、城市、薪资和奖金等属性：

public class Student {
    private String name;
    private int age;
    private String city;
    private double salary;
    private double incentive;

    public Student(String name, int age, String city, double salary, double incentive) {
        this.name = name;
        this.age = age;
        this.city = city;
        this.salary = salary;
        this.incentive = incentive;
    }

    // Getters for all fields
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getCity() { return city; }
    public double getSalary() { return salary; }
    public double getIncentive() { return incentive; }

    @Override
    public String toString() {
        return "Student{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", city='" + city + '\'' +
               ", salary=" + salary +
               ", incentive=" + incentive +
               '}';
    }
}

我们的目标是将具有相同 name、age 和 city 的学生进行分组，并将其 salary 和 incentive 进行累加。

初次尝试时，开发者可能倾向于使用 Collectors.toMap，并尝试将多个属性作为 Map 的键。例如，使用 AbstractMap.SimpleEntry：

// 编译错误示例
// List<Student> res = new ArrayList<>(students.stream()
//     .collect(Collectors.toMap(
//         ec -> new AbstractMap.SimpleEntry<>(ec.getName(), ec.getAge(), ec.getCity()), // 编译错误：SimpleEntry只接受两个参数
//         Function.identity(),
//         (a, b) -> new Student(
//             a.getName(), a.getAge(), a.getCity(), a.getSalary() + b.getSalary(), a.getIncentive() + b.getIncentive()
//         )
//     ))
//     .values());

这个尝试会遇到两个主要问题：

  1. AbstractMap.SimpleEntry 只能接受两个参数作为键值对，无法直接用于表示三个属性的复合键。
  2. double 类型的加法直接使用 + 运算符即可，如果尝试使用 add() 方法，会提示“Cannot resolve method 'add(double)'”，因为 double 是基本类型，没有 add 方法（除非 salary 或 incentive 被定义为 Double 对象，并被错误地期望有 add 方法）。

为了解决多属性分组的问题，我们需要一个能够封装这些属性并正确实现 equals 和 hashCode 方法的自定义对象作为 Map 的键。

方案一：构建复合键

要将多个属性作为一个整体进行分组，最清晰且可维护的方式是创建一个专门的类来表示这个复合键。对于 Java 8，我们需要手动实现 equals 和 hashCode 方法。

public static class NameAgeCity {
    private String name;
    private int age;
    private String city;

    public NameAgeCity(String name, int age, String city) {
        this.name = name;
        this.age = age;
        this.city = city;
    }

    public String getName() { return name; }
    public int getAge() { return age; }
    public String getCity() { return city; }

    // 静态工厂方法，方便从 Student 对象创建 NameAgeCity 实例
    public static NameAgeCity from(Student s) {
        return new NameAgeCity(s.getName(), s.getAge(), s.getCity());
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        NameAgeCity that = (NameAgeCity) o;
        return age == that.age &&
               Objects.equals(name, that.name) &&
               Objects.equals(city, that.city);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age, city);
    }

    @Override
    public String toString() {
        return "NameAgeCity{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", city='" + city + '\'' +
               '}';
    }
}

重要提示：

  • equals 和 hashCode 方法的正确实现对于将自定义对象用作 Map 的键至关重要。equals 定义了两个对象何时被认为是相等的，而 hashCode 则用于提高哈希表的查找效率。不正确实现会导致分组失败或性能问题。
  • 对于 Java 16 及更高版本，可以使用 record 类型更简洁地定义这样的复合键，编译器会自动生成构造函数、equals、hashCode 和 toString 方法。

方案二：自定义聚合逻辑

在分组之后，我们需要将每个分组内的 salary 和 incentive 进行累加。由于我们希望得到一个聚合后的新对象，而不是修改原始 Student 对象，或者如果 Student 对象是不可变的，我们可以引入一个专门的类 AggregatedValues 来存储聚合结果。

AggregatedValues 将充当一个可变的累加器，它会在流处理过程中收集和合并数据。

public static class AggregatedValues {
    private String name;
    private int age;
    private String city;
    private double salary;
    private double incentive;

    // 默认构造函数，用于 Collectors.of 的 supplier
    public AggregatedValues() {
        // 初始值通常为0或null
    }

    // Getters for aggregated values
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getCity() { return city; }
    public double getSalary() { return salary; }
    public double getIncentive() { return incentive; }

    // 累加器方法：将一个 Student 对象的数据累加到当前 AggregatedValues 实例
    public void accept(Student s) {
        // 首次接受 Student 时，初始化基本信息
        if (name == null) name = s.getName();
        if (age == 0) age = s.getAge(); // 假设age不会是0作为有效分组键
        if (city == null) city = s.getCity();

        // 累加薪资和奖金
        this.salary += s.getSalary();
        this.incentive += s.getIncentive();
    }

    // 合并器方法：将另一个 AggregatedValues 实例的数据合并到当前实例
    public AggregatedValues merge(AggregatedValues other) {
        this.salary += other.salary;
        this.incentive += other.incentive;
        return this; // 返回当前实例以支持链式调用
    }

    // 可选：将聚合结果转换回 Student 对象
    public Student toStudent() {
        return new Student(name, age, city, salary, incentive);
    }

    @Override
    public String toString() {
        return "AggregatedValues{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", city='" + city + '\'' +
               ", salary=" + salary +
               ", incentive=" + incentive +
               '}';
    }
}

整合方案：使用 Collectors.groupingBy 与 Collector.of

现在，我们可以将上述两个方案结合起来，使用 Collectors.groupingBy 进行分组，并使用 Collector.of 创建一个自定义的下游收集器来执行聚合操作。

Collector.of 方法需要四个参数：

  1. supplier (供应器): 一个函数，用于创建新的结果容器（在这里是 AggregatedValues 的实例）。
  2. accumulator (累加器): 一个函数，用于将流中的元素添加到结果容器中（在这里是 AggregatedValues::accept）。
  3. combiner (合并器): 一个函数，用于将两个结果容器合并（在并行流中特别有用，在这里是 AggregatedValues::merge）。
  4. finisher (终结器，可选): 一个函数，用于对最终结果容器进行转换（例如，将 AggregatedValues 转换回 Student）。

完整示例代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

public class StudentAggregator {

    // Student 类定义 (如上所示)
    public static class Student {
        private String name;
        private int age;
        private String city;
        private double salary;
        private double incentive;

        public Student(String name, int age, String city, double salary, double incentive) {
            this.name = name;
            this.age = age;
            this.city = city;
            this.salary = salary;
            this.incentive = incentive;
        }

        public String getName() { return name; }
        public int getAge() { return age; }
        public String getCity() { return city; }
        public double getSalary() { return salary; }
        public double getIncentive() { return incentive; }

        @Override
        public String toString() {
            return "Student{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   ", city='" + city + '\'' +
                   ", salary=" + salary +
                   ", incentive=" + incentive +
                   '}';
        }
    }

    // NameAgeCity 复合键类定义 (如上所示)
    public static class NameAgeCity {
        private String name;
        private int age;
        private String city;

        public NameAgeCity(String name, int age, String city) {
            this.name = name;
            this.age = age;
            this.city = city;
        }

        public static NameAgeCity from(Student s) {
            return new NameAgeCity(s.getName(), s.getAge(), s.getCity());
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            NameAgeCity that = (NameAgeCity) o;
            return age == that.age &&
                   Objects.equals(name, that.name) &&
                   Objects.equals(city, that.city);
        }

        @Override
        public int hashCode() {
            return Objects.hash(name, age, city);
        }

        @Override
        public String toString() {
            return "NameAgeCity{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   ", city='" + city + '\'' +
                   '}';
        }
    }

    // AggregatedValues 聚合容器类定义 (如上所示)
    public static class AggregatedValues {
        private String name;
        private int age;
        private String city;
        private double salary;
        private double incentive;

        public AggregatedValues() { }

        public String getName() { return name; }
        public int getAge() { return age; }
        public String getCity() { return city; }
        public double getSalary() { return salary; }
        public double getIncentive() { return incentive; }

        public void accept(Student s) {
            if (name == null) name = s.getName();
            if (age == 0) age = s.getAge(); // Assuming age 0 is not a valid grouping key initially
            if (city == null) city = s.getCity();
            this.salary += s.getSalary();
            this.incentive += s.getIncentive();
        }

        public AggregatedValues merge(AggregatedValues other) {
            this.salary += other.salary;
            this.incentive += other.incentive;
            return this;
        }

        public Student toStudent() {
            return new Student(name, age, city, salary, incentive);
        }

        @Override
        public String toString() {
            return "AggregatedValues{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   ", city='" + city + '\'' +
                   ", salary=" + salary +
                   ", incentive=" + incentive +
                   '}';
        }
    }

    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        // For Java 8, use Collections.addAll or Arrays.asList for list initialization
        Collections.addAll(students,
            new Student("Raj", 10, "Pune", 10000, 100),
            new Student("Raj", 10, "Pune", 20000, 200),
            new Student("Raj", 20, "Pune", 10000, 100),
            new Student("Ram", 30, "Pune", 10000, 100),
            new Student("Ram", 30, "Pune", 30000, 300),
            new Student("Seema", 10, "Pune", 10000, 100)
        );

        // 方案一：聚合结果为 AggregatedValues 列表
        List<AggregatedValues> aggregatedValuesList = students.stream()
            .collect(Collectors.groupingBy(
                NameAgeCity::from, // keyMapper: 将 Student 映射为 NameAgeCity 复合键
                Collectors.of(     // downstream Collector: 自定义聚合逻辑
                    AggregatedValues::new,    // supplier: 创建新的 AggregatedValues 实例
                    AggregatedValues::accept, // accumulator: 将 Student 累加到 AggregatedValues
                    AggregatedValues::merge   // combiner: 合并两个 AggregatedValues 实例
                )
            ))
            .values().stream() // 获取 Map 的所有值 (AggregatedValues 实例)
            .collect(Collectors.toList()); // 收集为列表

        System.out.println("--- AggregatedValues 列表 ---");
        aggregatedValuesList.forEach(System.out::println);

        // 方案二：聚合结果直接转换为 Student 列表 (使用 finisher)
        List<Student> aggregatedStudentsList = students.stream()
            .collect(Collectors.groupingBy(
                NameAgeCity::from, // keyMapper
                Collectors.of(     // downstream Collector
                    AggregatedValues::new,      // supplier
                    AggregatedValues::accept,   // accumulator
                    AggregatedValues::merge,    // combiner
                    AggregatedValues::toStudent // finisherFunction: 将 AggregatedValues 转换为 Student
                )
            ))
            .values().stream() // 获取 Map 的所有值 (此时已经是 Student 实例)
            .collect(Collectors.toList()); // 收集为列表

        System.out.println("\n--- 聚合后的 Student 列表 ---");
        aggregatedStudentsList.forEach(System.out::println);
    }
}

输出结果：

--- AggregatedValues 列表 ---
AggregatedValues{name='Raj', age=20, city='Pune', salary=10000.0, incentive=100.0}
AggregatedValues{name='Raj', age=10, city='Pune', salary=30000.0, incentive=300.0}
AggregatedValues{name='Ram', age=30, city='Pune', salary=40000.0, incentive=400.0}
AggregatedValues{name='Seema', age=10, city='Pune', salary=10000.0, incentive=100.0}

--- 聚合后的 Student 列表 ---
Student{name='Raj', age=20, city='Pune', salary=10000.0, incentive=100.0}
Student{name='Raj', age=10, city='Pune', salary=30000.0, incentive=300.0}
Student{name='Ram', age=30, city='Pune', salary=40000.0, incentive=400.0}
Student{name='Seema', age=10, city='Pune', salary=10000.0, incentive=100.0}

可以看到，Raj, 10, Pune 的学生数据被正确聚合，薪资和奖金分别累加为 30000 和 300。

注意事项与最佳实践

  1. equals 和 hashCode 的重要性： 在使用自定义对象作为 Map 的键时，务必正确实现 equals 和 hashCode 方法。equals 用于判断两个键是否逻辑相等，而 hashCode 用于快速定位键在哈希表中的位置。如果它们不一致，Map 将无法正确地识别相同的键，导致分组错误。
  2. 可变容器的性能： AggregatedValues 作为可变容器，在 Collector.of 的 accumulator 阶段直接修改自身状态，这种“可变归约”在处理大量数据时通常比创建大量中间不可变对象具有更好的性能。
  3. Java 版本兼容性： 本教程提供的 NameAgeCity 类是 Java 8 兼容的。对于 Java 16+，可以使用 record 关键字来更简洁地定义复合键。例如：`public record NameAgeCity(String name, int age, String

到这里，我们也就讲完了《Java8Stream分组聚合教程：对象处理详解》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！

美图秀秀制作微信头像步骤详解美图秀秀制作微信头像步骤详解
上一篇
美图秀秀制作微信头像步骤详解
Windows默认程序设置技巧
下一篇
Windows默认程序设置技巧
查看更多
最新文章
查看更多
课程推荐
  • 前端进阶之JavaScript设计模式
    前端进阶之JavaScript设计模式
    设计模式是开发人员在软件开发过程中面临一般问题时的解决方案，代表了最佳的实践。本课程的主打内容包括JS常见设计模式以及具体应用场景，打造一站式知识长龙服务，适合有JS基础的同学学习。
    543次学习
  • GO语言核心编程课程
    GO语言核心编程课程
    本课程采用真实案例，全面具体可落地，从理论到实践，一步一步将GO核心编程技术、编程思想、底层实现融会贯通，使学习者贴近时代脉搏，做IT互联网时代的弄潮儿。
    516次学习
  • 简单聊聊mysql8与网络通信
    简单聊聊mysql8与网络通信
    如有问题加微信：Le-studyg；在课程中，我们将首先介绍MySQL8的新特性，包括性能优化、安全增强、新数据类型等，帮助学生快速熟悉MySQL8的最新功能。接着，我们将深入解析MySQL的网络通信机制，包括协议、连接管理、数据传输等，让
    500次学习
  • JavaScript正则表达式基础与实战
    JavaScript正则表达式基础与实战
    在任何一门编程语言中,正则表达式,都是一项重要的知识,它提供了高效的字符串匹配与捕获机制,可以极大的简化程序设计。
    487次学习
  • 从零制作响应式网站—Grid布局
    从零制作响应式网站—Grid布局
    本系列教程将展示从零制作一个假想的网络科技公司官网，分为导航，轮播，关于我们，成功案例，服务流程，团队介绍，数据部分，公司动态，底部信息等内容区块。网站整体采用CSSGrid布局，支持响应式，有流畅过渡和展现动画。
    485次学习
查看更多
AI推荐
  • ChatExcel酷表：告别Excel难题，北大团队AI助手助您轻松处理数据
    ChatExcel酷表
    ChatExcel酷表是由北京大学团队打造的Excel聊天机器人，用自然语言操控表格，简化数据处理，告别繁琐操作，提升工作效率！适用于学生、上班族及政府人员。
    3179次使用
  • Any绘本：开源免费AI绘本创作工具深度解析
    Any绘本
    探索Any绘本（anypicturebook.com/zh），一款开源免费的AI绘本创作工具，基于Google Gemini与Flux AI模型，让您轻松创作个性化绘本。适用于家庭、教育、创作等多种场景，零门槛，高自由度，技术透明，本地可控。
    3390次使用
  • 可赞AI：AI驱动办公可视化智能工具，一键高效生成文档图表脑图
    可赞AI
    可赞AI，AI驱动的办公可视化智能工具，助您轻松实现文本与可视化元素高效转化。无论是智能文档生成、多格式文本解析，还是一键生成专业图表、脑图、知识卡片，可赞AI都能让信息处理更清晰高效。覆盖数据汇报、会议纪要、内容营销等全场景，大幅提升办公效率，降低专业门槛，是您提升工作效率的得力助手。
    3419次使用
  • 星月写作：AI网文创作神器，助力爆款小说速成
    星月写作
    星月写作是国内首款聚焦中文网络小说创作的AI辅助工具，解决网文作者从构思到变现的全流程痛点。AI扫榜、专属模板、全链路适配，助力新人快速上手，资深作者效率倍增。
    4525次使用
  • MagicLight.ai：叙事驱动AI动画视频创作平台 | 高效生成专业级故事动画
    MagicLight
    MagicLight.ai是全球首款叙事驱动型AI动画视频创作平台，专注于解决从故事想法到完整动画的全流程痛点。它通过自研AI模型，保障角色、风格、场景高度一致性，让零动画经验者也能高效产出专业级叙事内容。广泛适用于独立创作者、动画工作室、教育机构及企业营销，助您轻松实现创意落地与商业化。
    3799次使用
查看更多
相关文章
关于我们 免责声明 意见反馈 联系我们 内容提交
Golang学习网：公益在线Go学习平台，帮助Go学习者快速成长！
技术交流群
Copyright 2023 http://www.17golang.com/ All Rights Reserved ｜ 苏ICP备2023003363号-1
  • Golang学习网
    关注公众号
    Golang学习网
微信登录更方便
  • 密码登录
  • 注册账号
忘记密码
登录即同意 用户协议 和 隐私政策
返回登录
  • 重置密码
发送验证码