使用 Java Stream 高效实现按属性分组并获取最大值映射

import java.util.Date;
import java.util.Objects;

public class StudentGrade {
    private int studentId;
    private double value;
    private Date date; // 记录日期，本例中不用于比较，但可用于其他场景

    public StudentGrade(int studentId, double value, Date date) {
        this.studentId = studentId;
        this.value = value;
        this.date = date;
    }

    public int getStudentId() {
        return studentId;
    }

    public double getValue() {
        return value;
    }

    public Date getDate() {
        return date;
    }

    @Override
    public String toString() {
        return "StudentGrade{" +
               "studentId=" + studentId +
               ", value=" + value +
               ", date=" + date +
               '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        StudentGrade that = (StudentGrade) o;
        return studentId == that.studentId &&
               Double.compare(that.value, value) == 0 &&
               Objects.equals(date, that.date);
    }

    @Override
    public int hashCode() {
        return Objects.hash(studentId, value, date);
    }
}

import java.util.*;
import java.util.stream.Collectors;

public class GradeProcessor {

    /**
     * 使用 Collectors.groupingBy 和 Collectors.maxBy 获取每个学生的最高成绩
     * @param grades 学生成绩列表
     * @return 包含每个学生最高成绩的映射
     */
    public Map<Integer, StudentGrade> getMaxGradeByStudentUsingGroupingBy(List<StudentGrade> grades) {
        // 1. 按 studentId 分组，并找出每个组中 value 最大的 StudentGrade，结果为 Optional
        Map<Integer, Optional<StudentGrade>> maxGradesOptional = grades.stream().collect(
            Collectors.groupingBy(
                StudentGrade::getStudentId, // 根据 studentId 分组
                Collectors.maxBy(Comparator.comparing(StudentGrade::getValue))) // 找出每个组中 value 最大的元素
        );

        // 2. 遍历 Optional 结果，将其转换为最终的 Map
        Map<Integer, StudentGrade> finalGrades = new HashMap<>();
        maxGradesOptional.forEach((studentId, optionalGrade) ->
            optionalGrade.ifPresent(grade -> finalGrades.put(studentId, grade))
        );
        return finalGrades;
    }
}

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collectors;

public class GradeProcessor {

    /**
     * 使用 Collectors.toMap 和 BinaryOperator.maxBy 高效获取每个学生的最高成绩
     * @param grades 学生成绩列表
     * @return 包含每个学生最高成绩的映射
     */
    public Map<Integer, StudentGrade> getMaxGradeByStudentOptimized(List<StudentGrade> grades) {
        return grades.stream()
                .collect(Collectors.toMap(
                    StudentGrade::getStudentId, // keyMapper: 提取 studentId 作为 Map 的键
                    Function.identity(),        // valueMapper: 元素本身 (StudentGrade 对象) 作为 Map 的值
                    // mergeFunction: 当遇到重复的 studentId 时，选择 value 最大的 StudentGrade 对象
                    BinaryOperator.maxBy(Comparator.comparing(StudentGrade::getValue))
                ));
    }
}

import java.util.*;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collectors;

public class GradeProcessor {

    // StudentGrade 类定义如上所示

    public Map<Integer, StudentGrade> getMaxGradeByStudentUsingGroupingBy(List<StudentGrade> grades) {
        Map<Integer, Optional<StudentGrade>> maxGradesOptional = grades.stream().collect(
            Collectors.groupingBy(
                StudentGrade::getStudentId,
                Collectors.maxBy(Comparator.comparing(StudentGrade::getValue)))
        );

        Map<Integer, StudentGrade> finalGrades = new HashMap<>();
        maxGradesOptional.forEach((studentId, optionalGrade) ->
            optionalGrade.ifPresent(grade -> finalGrades.put(studentId, grade))
        );
        return finalGrades;
    }

    public Map<Integer, StudentGrade> getMaxGradeByStudentOptimized(List<StudentGrade> grades) {
        return grades.stream()
                .collect(Collectors.toMap(
                    StudentGrade::getStudentId,
                    Function.identity(),
                    BinaryOperator.maxBy(Comparator.comparing(StudentGrade::getValue))
                ));
    }

    public static void main(String[] args) {
        List<StudentGrade> grades = Arrays.asList(
            new StudentGrade(101, 85.0, new Date(123, 0, 1)),
            new StudentGrade(102, 92.5, new Date(123, 0, 2)),
            new StudentGrade(101, 90.0, new Date(123, 0, 3)), // 学生101的更高成绩
            new StudentGrade(103, 78.0, new Date(123, 0, 4)),
            new StudentGrade(102, 88.0, new Date(123, 0, 5)), // 学生102的较低成绩
            new StudentGrade(101, 88.0, new Date(123, 0, 6)), // 学生101的次高成绩
            new StudentGrade(103, 95.0, new Date(123, 0, 7))  // 学生103的更高成绩
        );

        GradeProcessor processor = new GradeProcessor();

        System.out.println("--- 使用 groupingBy + maxBy ---");
        Map<Integer, StudentGrade> result1 = processor.getMaxGradeByStudentUsingGroupingBy(grades);
        result1.forEach((id, grade) -> System.out.println("Student ID: " + id + ", Max Grade: " + grade));
        // 预期输出:
        // Student ID: 101, Max Grade: StudentGrade{studentId=101, value=90.0, date=Wed Jan 03 00:00:00 CST 2023}
        // Student ID: 102, Max Grade: StudentGrade{studentId=102, value=92.5, date=Tue Jan 02 00:00:00 CST 2023}
        // Student ID: 103, Max Grade: StudentGrade{studentId=103, value=95.0, date=Sat Jan 07 00:00:00 CST 2023}

        System.out.println("\n--- 使用 toMap + BinaryOperator.maxBy (优化方案) ---");
        Map<Integer, StudentGrade> result2 = processor.getMaxGradeByStudentOptimized(grades);
        result2.forEach((id, grade) -> System.out.println("Student ID: " + id + ", Max Grade: " + grade));
        // 预期输出与方法一相同，但代码更简洁
    }
}