【为什么要同时重写hashcode()和equals()方法】

上结论：

1. 重写equals方法是为了比较两个不同对象的值是否相等；
2. 重写hashCode是为了让同一个Class对象的两个具有相同值的对象的Hash值相等；
3. 同时重写hashCode()与equals()是为了满足HashSet、HashMap等此类集合的相同对象的不重复存储；

举例说明：

1. 新建一个class类对象Student，定义一个属性id；
2. 创建两个对象（s1，s2），使他们的id都是1，此时没有重写 hashcode（）方法和 equals（)方法。注意他们的id虽然相同，但是他们在内存中的地址并不相同。
3. 把s1放入hashmap中，通过s2来取；
4. 结果：必然是null；
5. 原因：①没有重写hashcode方法；②没有重写equals方法。

开始分析：

①两个方法均为重写

首先，我们往 hashmap里放s1时，就会调用这个类的hashcode方法计算它的hash值，随后把s1放入hash值所指引的内存位置；但是我们没有在Student里定义hashcode方法，这里调用的hashcode方法是object类中的hashcode方法，而object类的hashcode方法返回的hash值其实是s1对象的内存地址。
而s1，和s2的内存地址是不一样的，所以根据s2的内存地址拿到的是null。

②重写了hashcode 未重写equals方法

重写完hashcode方法后，这个时候由于s1,s2的值是一样的，所以根据hash函数得到的hash值是一样的。
但是根据s2,去取s1依旧是null，这是因为s1，s2,的hash值是一样的，产生了hash冲突，这个时候链表上可能会存在多个hash值相同的值，这个时候就需要通过 equals 方法来判断两者是否相等。
而由于我们没有在Student中重写equals 方法，系统在这里调用的依旧是object 类的 equals() 方法。object类的固有方法是根据两个对象的内存地址来判断，所以s1,s2必然是不相等的，这就是重写了hashcode方法后依然得到的是 null的原因。

上代码

public class Student {
    private String id;
    private String name;
    private String age;
    
    public Student() {}
    public Student(String id) {
        this.id = id;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
	// 重写equals
    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()){
            return false;
        }
        Student student = (Student) o;
        return  Objects.equals(id, student.id) 
         		&& Objects.equals(name, student.name) 
        	 	&& Objects.equals(age, student.age);
    }
    // 重写hashcode
    @Override
    public int hashCode() {
        return Objects.hash(id, name, age);
    }
}

主函数测试

public class StudentMain {
    public static void main(String[] args) {
        Student s1 = new Student("11");
        Student s2 = new Student("11");
        System.out.println("s1的hash值："+s1.hashCode());
        System.out.println("s2的hash值："+s2.hashCode());
        System.out.println("s1与s2比较的结果："+s1.equals(s2));
        HashMap<Object, String> hashMap = new HashMap<>();
        hashMap.put(s1,s1.getId());
        System.out.println("通过s2拿s1存储的值:"+hashMap.get(s2));
    }
}

情况1：均未重写

s1的hash值：2125039532
s2的hash值：312714112
s1与s2比较的结果：false
通过s2拿s1存储的值:null

情况2：重写了hashcode

s1的hash值：1536639
s2的hash值：1536639
s1与s2比较的结果：false
通过s2拿s1存储的值:null

情况3：重写了equals

s1的hash值：2125039532
s2的hash值：312714112
s1与s2比较的结果：true
通过s2拿s1存储的值:null

情况4：重写了hashcode和equals

s1的hash值：1536639
s2的hash值：1536639
s1与s2比较的结果：true
通过s2拿s1存储的值:11

以上结果显而易见！