Java Stream API：按属性分组并获取最大值映射的优雅实践

import java.util.Date;

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

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

public class GradeProcessor {

    public Map<Integer, StudentGrade> getMaxGradeByStudentTraditional(List<StudentGrade> grades) {
        // 第一步：按 studentId 分组，并找出每个分组中的最大成绩（Optional）
        Map<Integer, Optional<StudentGrade>> maxGradesOptional = grades.stream().collect(
            Collectors.groupingBy(
                StudentGrade::getStudentId,
                Collectors.maxBy(Comparator.comparing(StudentGrade::getValue)))
        );

        // 第二步：遍历 Optional 映射，解包并放入新的 HashMap
        Map<Integer, StudentGrade> finalGrades = new HashMap<>();
        maxGradesOptional.entrySet().forEach(entry -> {
            entry.getValue().ifPresent(value -> finalGrades.put(entry.getKey(), value));
        });
        return finalGrades;
    }
}

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

public class GradeProcessor {

    public Map<Integer, StudentGrade> getMaxGradeByStudentOptimized(List<StudentGrade> grades) {
        return grades.stream()
            .collect(Collectors.toMap(
                StudentGrade::getStudentId, // keyMapper: 以 studentId 作为键
                Function.identity(),        // valueMapper: 以 StudentGrade 对象本身作为值
                BinaryOperator.maxBy(Comparator.comparing(StudentGrade::getValue)) // mergeFunction: 当键冲突时，比较两个 StudentGrade 的 value，保留较大的
            ));
    }

    public static void main(String[] args) {
        GradeProcessor processor = new GradeProcessor();

        List<StudentGrade> studentGrades = Arrays.asList(
            new StudentGrade(1, 85.5, new Date(120, 0, 1)), // Jan 1, 2020
            new StudentGrade(2, 90.0, new Date(120, 1, 15)), // Feb 15, 2020
            new StudentGrade(1, 92.0, new Date(120, 2, 10)), // Mar 10, 2020 (Higher for student 1)
            new StudentGrade(3, 78.0, new Date(120, 3, 5)), // Apr 5, 2020
            new StudentGrade(2, 88.0, new Date(120, 4, 20)), // May 20, 2020 (Lower for student 2)
            new StudentGrade(1, 89.0, new Date(120, 5, 1)), // Jun 1, 2020 (Lower for student 1)
            new StudentGrade(3, 95.0, new Date(120, 6, 1)), // Jul 1, 2020 (Higher for student 3)
            new StudentGrade(4, 80.0, new Date(120, 7, 1))  // Aug 1, 2020
        );

        System.out.println("原始成绩列表:");
        studentGrades.forEach(System.out::println);
        System.out.println("\n-------------------------------------\n");

        Map<Integer, StudentGrade> maxGrades = processor.getMaxGradeByStudentOptimized(studentGrades);

        System.out.println("每个学生的最高成绩记录:");
        maxGrades.forEach((studentId, grade) ->
            System.out.println("学生ID: " + studentId + ", 最高成绩: " + grade)
        );
        /* 预期输出:
        学生ID: 1, 最高成绩: StudentGrade{studentId=1, value=92.0, date=Tue Mar 10 00:00:00 CST 2020}
        学生ID: 2, 最高成绩: StudentGrade{studentId=2, value=90.0, date=Sat Feb 15 00:00:00 CST 2020}
        学生ID: 3, 最高成绩: StudentGrade{studentId=3, value=95.0, date=Wed Jul 01 00:00:00 CST 2020}
        学生ID: 4, 最高成绩: StudentGrade{studentId=4, value=80.0, date=Sat Aug 01 00:00:00 CST 2020}
        */
    }
}