为什么在重写 equals方法的同时必须重写 hashcode方法

我们都知道java语言是完全面向对象的，在java中，所有的对象都是继承于object类。
其 equals 方法比较的是两个对象的引用指向的地址，hashcode 是一个本地方法，返回的是对象地址值。ojbect类中有两个方法equals、hashcode，这两个方法都是用来比较两个对象是否相等的。

为何重写 equals方法的同时必须重写 hashcode方法呢

可以这样理解：重写了 equals 方法，判断对象相等的业务逻辑就变了，类的设计者不希望通过比较内存地址来比较两个对象是否相等，而 hashcode 方法继续按照地址去比较也没有什么意义了，索性就跟着一起变吧。

还有一个原因来源于集合。下面慢慢说~

举个例子：

在学校中，是通过学号来判断是不是这个人的。

下面代码中情景为学籍录入，学号 123 被指定给学生 tom，学号 456 被指定给学生 jerry，学号 123 被失误指定给 lily。而在录入学籍的过程中是不应该出现学号一样的情况的。

根据情景需求是不能添加重复的对象，可以通过 hashset 实现。

public class test {
public static void main(string[] args) {
student stu = new student(123,"tom");
hashset<student> set = new hashset<>();
set.add(stu);
set.add(new student(456, "jerry"));
set.add(new student(123, "lily"));
iterator<student> iterator = set.iterator();
while (iterator.hasnext()) {
student student = iterator.next(); 
system.out.println(student.getstunum() + " --- " + student.getname());
}
}
};
class student {
private int stunum;
private string name;
public student(int stunum,string name){
this.stunum = stunum;
this.name = name;
}
public int getstunum() {
return stunum;
}
public string getname() {
return name;
}
@override
public boolean equals(object obj) {
if(this==obj)
return true;
if(obj instanceof student){
if(this.getstunum()==((student)obj).getstunum())
return true;
}
return false;
}
} 

输出为：

123 --- lily
456 --- jerry
123 --- tom

根据输出我们发现，再次将学号 123 指定给 lily 居然成功了。到底哪里出了问题呢?

我们看一下 hashset 的 add 方法：

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

其实 hashset 是通过 hashmap 实现的，由此我们追踪到 hashmap 的 put 方法：

public v put(k key, v value) {
if (table == empty_table) {
inflatetable(threshold);
}
if (key == null)
return putfornullkey(value);
int hash = hash(key);
int i = indexfor(hash, table.length);
for (entry<k,v> e = table[i]; e != null; e = e.next) {
object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
v oldvalue = e.value;
e.value = value;
e.recordaccess(this);
return oldvalue;
}
}
modcount++;
addentry(hash, key, value, i);
return null;
} 

1.根据 key，也就是 hashset 所要添加的对象，得到 hashcode，由 hashcode 做特定位运算得到 hash 码；

2.利用 hash 码定位找到数组下标，得到链表的链首；

3.遍历链表寻找有没有相同的 key，判断依据是 e.hash == hash && ((k = e.key) == key || key.equals(k))。在add lily 的时候，由于重写了 equals 方法，遍历到 tom 的时候第二个条件应该是 true；但是因为 hashcode 方法还是使用父类的，故而 tom 和 lily的 hashcode 不同也就是 hash 码不同，第一个条件为 false。这里得到两个对象是不同的所以 hashset 添加 lily 成功。

总结出来原因是没有重写 hashcode 方法，下面改造一下：

public class test {
public static void main(string[] args) {
student stu = new student(123,"tom");
hashset<student> set = new hashset<>();
set.add(stu);
set.add(new student(456, "jerry"));
set.add(new student(123, "lily"));
iterator<student> iterator = set.iterator();
while (iterator.hasnext()) {
student student = iterator.next(); 
system.out.println(student.getstunum() + " --- " + student.getname());
}
}
};
class student {
private int stunum;
private string name;
public student(int stunum,string name){
this.stunum = stunum;
this.name = name;
}
public int getstunum() {
return stunum;
}
public string getname() {
return name;
}
@override
public boolean equals(object obj) {
if(this==obj)
return true;
if(obj instanceof student){
if(this.getstunum()==((student)obj).getstunum())
return true;
}
return false;
}
@override
public int hashcode() {
return getstunum();
}
} 

输出：

456 --- jerry
123 --- tom

重写了 hashcode 方法返回学号。ok，大功告成。

有人可能会奇怪，e.hash == hash && ((k = e.key) == key || key.equals(k)) 这个条件是不是有点复杂了，我感觉只使用 equals 方法就可以了啊，为什么要多此一举去判断 hashcode 呢?

因为在 hashmap 的链表结构中遍历判断的时候，特定情况下重写的 equals 方法比较对象是否相等的业务逻辑比较复杂，循环下来更是影响查找效率。所以这里把 hashcode 的判断放在前面，只要 hashcode 不相等就玩儿完，不用再去调用复杂的 equals 了。很多程度地提升 hashmap 的使用效率。

所以重写 hashcode 方法是为了让我们能够正常使用 hashmap 等集合类，因为 hashmap 判断对象是否相等既要比较 hashcode 又要使用 equals 比较。而这样的实现是为了提高 hashmap 的效率。