JAVA重写equal方法后为什么必须要重写Hashcode方法

什么是hash表？

hash表是一种数据结构，提供了快速插入和快速查询的功能。插入和删除时间复杂度接近O(1)，hash表底层实现时基于数组的，而键值对<K,VALUE>中的k就是我们作为数组下标的重要依据，但实际上并不是以用户的key来存放的，而是获取到K的hashcode,来作为数组的下标。相当于经过hash函数做了一层映射值。hash函数算法怎么实现本章不予讨论。hash函数是根据对象的地址经过算法计算后返回的一串数字。(hash冲突后面我们在介绍)。这个过程又叫哈希化。那么这个数字并不是唯一的，可能会有重复，即哈希冲突。JAVA开发人员帮我们实现了几种解决hash冲突的方法。（hash冲突本章不解释，有兴趣的道友查阅资料即可）

hash表解释清楚了，下来看标题的问题，为什么重写equal方法后为什么必须要重写Hashcode方法。

java体系中的相等，和我们实际业务中的相等并不相同，java体系中的相等是真正意义上的相等，比如两个对象在内存中的地址相同，而我们业务中的相等意义是 比如两个user类，他们的姓名和年龄还有身份证号都一致，那么我们可以认为这两个人是相等的。java规范中规定，相等的两个对象他们的散列码必定相等。明白了这一点，来看一下小例子，例子中我重写了myplayer的equals方法，实现了我们业务意义上的相等。

import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class Maintest {

	public static void main(String[] args) throws IOException, InterruptedException {
		myplayer a = new myplayer("a",1);
		myplayer b = new myplayer("a",1);
		System.out.println(a.equals(b));
		System.out.println(b.equals(new myplayer("a",1)));
		Map map = new HashMap<myplayer,String>();
		map.put(a,"aaa");
		map.put(b,"bbbb");

		System.out.println(a.hashCode());
		System.out.println(b.hashCode());
		System.out.println((new myplayer("a",1)).hashCode());

		System.out.println(map.get(new myplayer("a",1)));

	}

}

class myplayer{

	String name;
	int age;

	public myplayer(String name, int age) {
		this.name = name;
		this.age = age;
	}

	@Override
	public boolean equals(Object obj) {


		if(this == obj) {
			return true;
		}

		if(! (obj instanceof myplayer)){
			return false;
		}

		myplayer my = (myplayer)obj;

		if(my.age == this.age && this.name.equals(my.name) ){
			return true;
		}else{
			return false;
		}

	}
}

最终打印的值为null,

为什么会拿到空值呢？虽然我们new出来的对象，从我们重写的equal方法上是相等的，但是他们的hashcode并不相同，自然而然在hash表中找不到以该hashcode为下标的值。
下面贴上一些hashmap的源码

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

    
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

他会先拿hashcode去hash表中查找，如果该下标对应的只有一个值，那么直接返回，如果存在hash冲突那么顺着链表一直往下进行equal比较，如果相等那么返回。（这种数组中存放链表的方式叫联链址法，是解决hash冲突的一种）

所以你明白了为什么重写equal方法后为什么必须要重写Hashcode方法吗？