重写equals时，为什么还要重写hashcode？

重写equals，为什么还要重写hashcode，大部分的复习资料都会这么写：
“如果两个对象相等，则 hashcode 一定也是相同的。两个对象相等,对两个对象分别调用 equals 方法都返回 true。但是，两个对象有相同的 hashcode 值，它们也不一定是相等的 。因此，equals 方法被覆盖过，则 hashCode 方法也必须被覆盖。”
加粗部分原话是对的，但是和本问题毫无关系。他只是把hashmap中哈希冲突的理论进行了简单的套用，就想当然的认为据此就可以得出，重写equals就必须重写hashcode，实则是大错特错。真正的原因其实是这样的：
1.euqals和==的区别。
这个相信大家稍微深入复习，都会很清晰。即equals 和 == 都是Object的方法。如果不对equals进行重写，那么他们就是功能是相同的，即比较两个对象的地址值是否相同。String中，之所以调用equals来比较两个字符串的值是否相同，是因为它重写了equals方法。
2.什么时候重写equlas，就要重写hashcode方法？
类里要用到hashmap、hashSet等散列表(来达到去重效果)的时候。如果在我们的类中，不需要用到散列表，那么只需要重写equals即可。因为重写equals方法，仅仅是为了满足我们特定的需求（一般是比较属性值是否相同）。而不重写hashcode，并不会影响我们实现这类需求。
3.为什么使用散列表时重写equals，还有重写hashcode？
因为hashcode默认使用地址进行散列的。此时equals比较是相同的，但是hashmap内部却仍然认为这是两个对象，导致运行结果和我们期望的不符。
举例说明：
现在定义一个Student类和一个测试类。Student包括姓名和年龄。

public class Student {
    String Name;
    int age;
    
    public Student(String Name,int age){
        this.Name = Name;
        this.age = age;
    }

public class Test {
    public static void main(String[] args) {
        Student s1 = new Student("小方",12);
        Student s2 = new Student("小方",12);
        System.out.println(s1.equals(s2));
    }
}

此时，程序返回false。
当我们重写equals后

public class Student {
    String Name;
    int age;

    public Student(String Name,int age){
        this.Name = Name;
        this.age = age;
    }


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

此时，我们想要的效果已经达到了。但是如果加入一个使用hashset来去重呢？

public class Test {
    public static void main(String[] args) {

        Set<Student> set = new HashSet<>();

        Student s1 = new Student("小方",12);
        Student s2 = new Student("小方",12);
        set.add(s1);
        set.add(s2);
        System.out.println(set.size());
        for(Student s:set){
            System.out.println(s);
        }
        System.out.println(s1.equals(s2));
    }
}

遍历hashset的值，我们居然发现，hashset的size竟然是2，两个被我们定义为equals的对象，竟然全都被写进去了。
现在，在Student类中重写hashcode。

public class Student {
    String Name;
    int age;

    public Student(String Name,int age){
        this.Name = Name;
        this.age = age;
    }


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

    @Override
    public int hashCode() {
        return Objects.hash(Name, age);
    }
    
    @Override
    public String toString() {
        return "Student{" +
                "Name='" + Name + '\'' +
                ", age=" + age +
                '}';
    }
}

可以看到，此时，hashset中只有1个对象了，也就是说另一个被去重了。这是为什么呢？
答案是从hashmap的源码中找。因为hashset的底层就是用hashmap来是实现的。先看hashset的add方法

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

可以看到，是把这个值存到了map里，其中，PRESENT==new Object();再看map的put方法，调用了putval。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

源码内容众多，但是我们只需要关注第13行那里。即当要put一个值的时候，要比较他的hash值和equals值。只有这两个都相同时，才认为这是两个相同的值。在本例中，如果不重写hashcode，此处的hash值就是对象的地址值，这当然是不同的。

总结： 重写equals，还要重写hashcode，是因为如果不重写hashcode，两个对象的hashcode值可能还是不同的，此时不满足hashmap中判断为同一个对象的条件，而会被认为是两个对象。重写hashcode，要对我们比较的属性都进行hash，从而保证了他们的hashcode也是一样的。