Java Stream API：高效聚合数据并获取分组最大值映射

public class StudentGrade {
    int studentId;
    double value; // 成绩值
    Date date;    // 成绩记录日期

    // 构造函数、Getter、Setter等省略
    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 +
               '}';
    }
}

// 传统但不够优化的方法示例
public Map<Integer, StudentGrade> getMaxGradeByStudentInefficient(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.entrySet().forEach(entry -> {
        entry.getValue().ifPresent(value -> finalGrades.put(entry.getKey(), value));
    });
    return finalGrades;
}

import java.util.Comparator;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.stream.Collectors;

public class StudentGradeProcessor {

    // ... StudentGrade class definition (as above) ...

    /**
     * 使用Java Stream API高效地获取每个学生的最大成绩。
     *
     * @param grades 包含所有学生成绩的列表。
     * @return 一个Map，键为studentId，值为该学生具有最大成绩值的StudentGrade对象。
     */
    public Map<Integer, StudentGrade> getMaxGradeByStudent(List<StudentGrade> grades) {
        return grades.stream()
                     .collect(Collectors.toMap(
                         StudentGrade::getStudentId, // keyMapper: 使用studentId作为Map的键
                         Function.identity(),        // valueMapper: 将StudentGrade对象本身作为Map的值
                         BinaryOperator.maxBy(Comparator.comparing(StudentGrade::getValue)) // mergeFunction: 当key冲突时，保留value最大的StudentGrade对象
                     ));
    }

    public static void main(String[] args) {
        List<StudentGrade> grades = List.of(
            new StudentGrade(1, 85.0, new Date(123, 0, 1)),
            new StudentGrade(2, 92.5, new Date(123, 0, 2)),
            new StudentGrade(1, 90.0, new Date(123, 0, 3)), // studentId 1 的新成绩，更高
            new StudentGrade(3, 78.0, new Date(123, 0, 4)),
            new StudentGrade(2, 88.0, new Date(123, 0, 5)), // studentId 2 的新成绩，更低
            new StudentGrade(1, 88.0, new Date(123, 0, 6))  // studentId 1 的新成绩，居中
        );

        StudentGradeProcessor processor = new StudentGradeProcessor();
        Map<Integer, StudentGrade> maxGrades = processor.getMaxGradeByStudent(grades);

        maxGrades.forEach((studentId, grade) ->
            System.out.println("Student ID: " + studentId + ", Max Grade: " + grade)
        );
        // 预期输出:
        // Student ID: 1, Max Grade: StudentGrade{studentId=1, value=90.0, date=Wed Jan 03 00:00:00 CST 2024}
        // Student ID: 2, Max Grade: StudentGrade{studentId=2, value=92.5, date=Tue Jan 02 00:00:00 CST 2024}
        // Student ID: 3, Max Grade: StudentGrade{studentId=3, value=78.0, date=Thu Jan 04 00:00:00 CST 2024}
    }
}