使用Java Stream聚合多表数据并按条件排序：以电影评分与预算为例-java教程-PHP中文网

使用Java Stream聚合多表数据并按条件排序：以电影评分与预算为例

碧海醫心

发布： 2025-09-13 15:03:03

原创

664人浏览过

使用Java Stream聚合多表数据并按条件排序：以电影评分与预算为例

本文详细介绍了如何利用Java Stream API处理关联数据，以电影评分和预算为例，演示了如何计算电影的平均得分，筛选出平均分最高的N部电影，并根据预算对其进行二次排序。通过构建数据模型、使用groupingBy、averagingDouble以及多阶段排序，高效地实现了复杂的数据聚合和筛选逻辑，为内存数据处理提供了专业的解决方案。

1. 场景概述与数据模型

在实际应用中，我们经常需要处理来自多个关联数据源的信息。本教程将解决一个典型问题：给定用户、电影和评分三张关联表的数据，如何找出平均得分最高的n部电影，并在此基础上，根据电影的预算对这n部电影进行排序。

为了模拟数据，我们定义以下Java record 类型作为数据模型：

// 电影评分记录
record Score(int userId, int movieId, int score) {}

// 电影信息记录
record Movie(int id, String name, int budget) {}

登录后复制

假设我们有以下示例数据：

电影数据 (List<Movie>) | id | name | budget | |----|------|--------| | 101| Mov 1| 200 | | 102| Mov 2| 500 | | 103| Mov 3| 300 |

评分数据 (List<Score>) | user_id | movie_id | score | |---------|----------|-------| | 1 | 101 | 6 | | 2 | 101 | 8 | | 1 | 102 | 6 | | 2 | 102 | 9 |

我们的目标是：

计算每部电影的平均得分。
找出平均得分最高的5部电影。
对这5部电影，按预算从高到低进行排序。

2. Java Stream实现步骤

Java Stream API提供了一种声明式的方式来处理集合数据，非常适合进行这种多阶段的聚合和转换操作。

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

2.1 准备数据与辅助结构

首先，我们需要初始化电影和评分数据。为了在后续步骤中能根据 movieId 快速查找 Movie 对象，我们通常会创建一个 Map<Integer, Movie>。

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.Map.Entry; // 注意导入 Map.Entry

public class MovieAnalysis {

    public static void main(String[] args) {
        // 示例数据初始化
        List<Movie> movies = List.of(
            new Movie(101, "Mov 1", 200),
            new Movie(102, "Mov 2", 500),
            new Movie(103, "Mov 3", 300));
        List<Score> scores = List.of(
            new Score(1, 101, 6),
            new Score(2, 101, 8),
            new Score(1, 102, 6),
            new Score(2, 102, 9));

        // 创建电影ID到电影对象的映射，便于后续查找
        Map<Integer, Movie> movieMap = movies.stream()
            .collect(Collectors.toMap(Movie::id, Function.identity()));
    }
}

登录后复制

2.2 计算每部电影的平均得分

利用 Collectors.groupingBy 和 Collectors.averagingDouble，我们可以轻松地计算出每部电影的平均得分。

序列猴子开放平台

具有长序列、多模态、单模型、大数据等特点的超大规模语言模型

查看详情

        // ... (接上文代码)

        // 1. 计算每部电影的平均得分
        // 结果是一个 Map<Integer, Double>，键是 movieId，值是平均得分
        Map<Integer, Double> movieAverageScores = scores.stream()
            .collect(Collectors.groupingBy(
                Score::movieId,                 // 按 movieId 分组
                Collectors.averagingDouble(Score::score) // 计算每个组的平均得分
            ));

        // movieAverageScores 内容示例：
        // {101=7.0, 102=7.5}

登录后复制

2.3 筛选并排序前N部电影

接下来，我们需要从 movieAverageScores 中找出平均得分最高的N部电影（这里是5部），然后将这些电影对象根据预算进行二次排序。

        // ... (接上文代码)

        // 2. 筛选平均得分最高的N部电影，并按预算排序
        List<Movie> top5Movies = movieAverageScores.entrySet().stream()
            // 将 Map 的 Entry 转换为 Stream，Entry 的键是 movieId，值是平均得分

            // 2.1 按平均得分降序排序
            .sorted(Collections.reverseOrder(Entry.comparingByValue()))

            // 2.2 限制只取前5个（平均得分最高的5部电影）
            .limit(5)

            // 2.3 将 Entry 转换为 Movie 对象：根据 movieId 从 movieMap 中查找对应的 Movie
            .map(entry -> movieMap.get(entry.getKey()))

            // 2.4 对这5部电影，按预算降序排序
            .sorted(Collections.reverseOrder(Comparator.comparing(Movie::budget)))

            // 2.5 收集结果到 List
            .toList();

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

登录后复制

3. 完整示例代码

将上述步骤整合，得到完整的Java Stream解决方案：

import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.Map.Entry;

public class MovieAnalysis {

    // 电影评分记录
    record Score(int userId, int movieId, int score) {}

    // 电影信息记录
    record Movie(int id, String name, int budget) {}

    public static void main(String[] args) {
        // 示例数据初始化
        List<Movie> movies = List.of(
            new Movie(101, "Mov 1", 200),
            new Movie(102, "Mov 2", 500),
            new Movie(103, "Mov 3", 300));
        List<Score> scores = List.of(
            new Score(1, 101, 6),
            new Score(2, 101, 8),
            new Score(1, 102, 6),
            new Score(2, 102, 9));

        // 1. 创建电影ID到电影对象的映射，便于后续查找
        Map<Integer, Movie> movieMap = movies.stream()
            .collect(Collectors.toMap(Movie::id, Function.identity()));

        // 2. 计算每部电影的平均得分，并找出平均得分最高的N部电影，然后按预算排序
        List<Movie> top5Movies = scores.stream()
            // 2.1 按 movieId 分组，并计算每组的平均得分
            .collect(Collectors.groupingBy(
                Score::movieId, 
                Collectors.averagingDouble(Score::score)))
            // 2.2 将 Map 的 Entry 转换为 Stream
            .entrySet().stream()
            // 2.3 按平均得分降序排序
            .sorted(Collections.reverseOrder(Entry.comparingByValue()))
            // 2.4 限制只取前5个 Entry
            .limit(5)
            // 2.5 将 Entry 的 movieId 转换为对应的 Movie 对象
            .map(entry -> movieMap.get(entry.getKey()))
            // 2.6 对这5部 Movie 对象，按预算降序排序
            .sorted(Collections.reverseOrder(Comparator.comparing(Movie::budget)))
            // 2.7 收集结果到 List
            .toList();

        // 打印最终结果
        top5Movies.forEach(System.out::println);
    }
}

登录后复制

4. 运行结果

根据提供的示例数据，上述代码将输出：

Movie[id=102, name=Mov 2, budget=500]
Movie[id=101, name=Mov 1, budget=200]

登录后复制

结果分析:

电影101 ("Mov 1") 的平均得分是 (6+8)/2 = 7.0。
电影102 ("Mov 2") 的平均得分是 (6+9)/2 = 7.5。
电影103 ("Mov 3") 没有评分数据，因此不会出现在平均得分的计算中。
在仅有的两部有评分的电影中，电影102的平均得分最高 (7.5)，电影101次之 (7.0)。
由于我们 limit(5)，这两部电影都将被选中。
最后，它们会根据预算降序排序：电影102 (预算500) 在前，电影101 (预算200) 在后。

5. 注意事项与总结

数据量考量： Java Stream API在处理内存中的集合数据时表现出色。对于非常庞大的数据集（例如，数百万甚至数十亿条记录），如果数据主要存储在数据库中，直接使用SQL查询（如聚合函数AVG()和ORDER BY）通常会更高效，因为数据库管理系统针对此类操作进行了高度优化，并能有效利用索引和分布式计算能力。
空值处理： 在实际应用中，movieMap.get(entry.getKey()) 可能会返回 null（如果 movieId 在 movies 列表中不存在）。为了健壮性，可以添加 filter(Objects::nonNull) 或使用 Optional 进行更安全的处理。
N值设置： limit(5) 可以根据需求调整为任意正整数N。
多阶段排序： 本示例展示了如何通过链式调用 sorted() 方法实现多阶段排序。第一次排序是基于平均得分，第二次排序是基于预算，但第二次排序只作用于第一次排序 limit 后的结果集。
代码可读性： 尽管Stream API很强大，但过于复杂的链式操作可能会降低代码可读性。适当地拆分Stream操作或使用辅助方法可以提高代码清晰度。