现在有两个学生名单，然后我想对比一下这两个名单的学生，名单一的学生id和名单二的学生的oldid是对应的。只比较,name,class,age,score这些字段.而且oldId可能为0或不存在

需求：
我自定义了一个Student类，其中Student类有id,oldid,name,class,age,score这些字段，然后现在有两个学生名单，然后我想对比一下这两个名单的学生，
第二个名单里的学生和第一个名单的学生相比，哪些学生是没变化的，哪些是新增的，哪些是修改的，删除了几个学生。
注意第一个名单的学生id和第二个名单的学生的oldid是对应的。然后写一个java代码去比较这两个名单，只比较,name,class,age,score这些字段.而且oldId可能为0或不存在

import java.util.Objects;

public class Student {
    public Student(int id, String name, String classRoom, int age, int score) {
        this.id = id;
        this.name = name;
        this.classRoom = classRoom;
        this.age = age;
        this.score = score;
    }

    public Student(int id, int oldId, String name, String classRoom, int age, int score) {
        this.id = id;
        this.oldId = oldId;
        this.name = name;
        this.classRoom = classRoom;
        this.age = age;
        this.score = score;
    }

    public Student() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getOldId() {
        return oldId;
    }

    public void setOldId(int oldId) {
        this.oldId = oldId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getClassRoom() {
        return classRoom;
    }

    public void setClassRoom(String classRoom) {
        this.classRoom = classRoom;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    private int id;
    private int oldId;
    private String name;
    private String classRoom;
    private int age;
    private int score;

    // 构造函数、getter和setter省略，根据需要添加

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return name.equals(student.name) &&
                classRoom.equals(student.classRoom) &&
                age == student.age &&
                score == student.score;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", oldId=" + oldId +
                ", name='" + name + '\'' +
                ", classRoom='" + classRoom + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}

具体的比较方法

import com.atguigu.demomptest.entity.Student;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class StudentComparator {

    public static void compareStudents(List<Student> list1, List<Student> list2) {
        Map<Integer, Student> map1 = new HashMap<>();
        Map<Integer, Student> map2 = new HashMap<>();
        int removedCount = 0;

        // 将第一个名单的学生存入map，以id为key
        for (Student s : list1) {
            map1.put(s.getId(), s);
        }

        // 遍历第二个名单，为每个学生标注状态
        for (Student s2 : list2) {
            if (s2.getOldId() != 0) {
                if (map1.containsKey(s2.getOldId())) {
                    Student s1 = map1.get(s2.getOldId());
                    if (s1.equals(s2)) {
                        System.out.println("Unchanged: " + s2);
                    } else {
                        System.out.println("Modified: " + s2);
                    }
                    map1.remove(s2.getOldId()); // 从map1中移除已匹配的学生
                } else {
                    System.out.println("Added: " + s2);
                }
            } else {
                System.out.println("Added: " + s2);
            }
            map2.put(s2.getId(), s2);
        }

        // 检查删除的学生
        for (Student s1 : map1.values()) {
            removedCount++;
        }

        System.out.println("Deleted students count: " + removedCount);
    }

    public static void main(String[] args) {
        // 示例代码，创建两个学生名单并调用比较方法
        List<Student> list1 = new ArrayList<>();
        List<Student> list2 = new ArrayList<>();

        Student student1 = new Student(1, "小王", "三一", 18, 90);
        Student student2 = new Student(2, "小赵", "三二", 18, 90);
        Student student3 = new Student(3, "小钱", "三三", 18, 90);
        Student student4 = new Student(4, "小孙", "三四", 19, 90);
        Student student5 = new Student(5, "小李", "三五", 18, 90);
        list1.add(student1);
        list1.add(student2);
        list1.add(student3);
        list1.add(student4);
        list1.add(student5);

        Student student6 = new Student(6, 1, "小王", "三一", 18, 90);
        Student student7 = new Student(7, 2, "小赵", "三二变", 18, 90);
        Student student8 = new Student(8, "小李", "三五增", 18, 90);
        Student student9 = new Student(9, "小张", "三五增", 18, 90);
        Student student10 = new Student(10, 5, "小李", "三五", 18, 90);
        list2.add(student6);
        list2.add(student7);
        list2.add(student8);
        list2.add(student9);
        list2.add(student10);
        compareStudents(list1, list2);
    }
}

不使用oldId作为键：我们通过遍历第二个名单，检查每个学生是否在第一个名单中存在，而不是通过oldId。
标记状态：如果第二个名单中的学生在第一个名单中存在，并且除了id和oldId之外的其他字段相同，则标记为“未变化”；如果字段不同，则标记为“修改”。如果第二个名单中的学生在第一个名单中不存在，则标记为“新增”。
统计删除的学生：在遍历完第二个名单后，检查第一个名单中剩余的学生，这些学生即为删除的学生。
这样，代码可以正确处理新增的学生（oldId可能为0或不存在），并且能够正确标记出未变化、修改和新增的学生，同时统计删除的学生数量。