重写equals的同时为何要重写hashCode？
结论
先直接上结论：
重写equals不一定要重写hashCode，得看情况。如果在没使用容器时其实是没必要的。
如果使用了HashMap等容器，并且使用了自定义对象作为Key是一定要重写的。
重写equals是为了在业务逻辑上判断实例之间是否相等。重写hascode是为了让集合快速判重。
hashCode()与equals()的规定：
1.如果两个对象相等，则hashcode一定也是相同的
2.两个对象相等,对两个equals()方法返回true
3.两个对象有相同的hashcode值，它们也不一定是相等的
4.综上，equals()方法被覆盖过，则hashCode()方法也必须被覆盖
5.hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等（即使这两个对象指向相同的数据）。
下面举个例子说明一定要重写。
当使用自定义类作为HashMap的Key时put时
如果只重写equals不重写hashCode会出现逻辑错误
先看下面的代码
publicclassTest{
staticclassOrder{
privateLongorderId;
publicOrder(LongorderId){
this.orderId=orderId;
}
publicLonggetOrderId(){
returnorderId;
}
publicvoidsetOrderId(LongorderId){
this.orderId=orderId;
}
@Override
publicbooleanequals(Objectobj){
if(obj!=null&&!(objinstanceofOrder)){
returnfalse;
}
returnObjects.equals(this.orderId,((Order)obj).orderId);
}
@Override
publicStringtoString(){
return"Order{"+
"orderId="+orderId+
'}';
}
}
publicstaticvoidmain(String[]args){
Mapmap=newHashMap<>();
Orderorder1=newOrder(1000000001L);
Orderorder2=newOrder(1000000001L);
map.put(order1,"");
map.put(order2,"");
System.out.println(map);
}
}
运行输出：
{Order{orderId=1000000001}=,Order{orderId=1000000001}=}
在代码中重写了equals方法，没重写hashCode方法。
equals重写的逻辑是：只要orderId相等那么这这两个对象就相等。
而从运行结果来看，两个orderId一致的对象却都成功put到了map中。这就是逻辑错误了，因为按照逻辑来说期望的结果应该只有一个Order在map中才对。
我们来看下HashMap的源码
只需要看写了注释的那个判断
publicVput(Kkey,Vvalue){
returnputVal(hash(key),key,value,false,true);
}
staticfinalinthash(Objectkey){
inth;
return(key==null)?0:(h=key.hashCode())^(h>>>16);
}
finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,
booleanevict){
Node[]tab;Nodep;intn,i;
if((tab=table)==null||(n=tab.length)==0)
n=(tab=resize()).length;
//通过hash算出索引通过索引取值==null的话直接直接插入到索引位置。
if((p=tab[i=(n-1)&hash])==null)
tab[i]=newNode(hash,key,value,null);
else{
Nodee;Kk;
if(p.hash==hash&&
((k=p.key)==key||(key!=null&&key.equals(k))))
e=p;
elseif(pinstanceofTreeNode)
e=((TreeNode)p).putTreeVal(this,tab,hash,key,value);
else{
for(intbinCount=0;;++binCount){
if((e=p.next)==null){
p.next=newNode(hash,key,value,null);
if(binCount>=TREEIFY_THRESHOLD-1)//-1for1st
treeifyBin(tab,hash);
break;
}
if(e.hash==hash&&
((k=e.key)==key||(key!=null&&key.equals(k))))
break;
p=e;
}
}
if(e!=null){//existingmappingforkey
VoldValue=e.value;
if(!onlyIfAbsent||oldValue==null)
e.value=value;
afterNodeAccess(e);
returnoldValue;
}
}
++modCount;
if(++size>threshold)
resize();
afterNodeInsertion(evict);
returnnull;
}
通过源码我们知道，只要hash码不一样的话就可以直接插入到数组中。然而正因为我们没重写hashCode方法，所以调用的是Object的hashCode方法。而Object的hashCode是使用对象在堆中的地址通过算法得出一个int类型的值，既然如此，那刚刚创建的两个对象的int类型的值肯定是不同的，所以两个Order都可以正常插入到数组中，从而出现了逻辑错误。
重写hashCode方法：
publicclassTestHash{
staticclassOrder{
privateLongorderId;
publicOrder(LongorderId){
this.orderId=orderId;
}
publicLonggetOrderId(){
returnorderId;
}
publicvoidsetOrderId(LongorderId){
this.orderId=orderId;
}
@Override
publicbooleanequals(Objectobj){
if(obj!=null&&!(objinstanceofOrder)){
returnfalse;
}
returnObjects.equals(this.orderId,((Order)obj).orderId);
}
@Override
publicinthashCode(){
//这里简单重写下实际开发根据自己需求重写即可。
returnthis.orderId.intValue()>>2;
}
@Override
publicStringtoString(){
return"Order{"+
"orderId="+orderId+
'}';
}
}
publicstaticvoidmain(String[]args){
Mapmap=newHashMap<>();
Orderorder1=newOrder(1000000001L);
Orderorder2=newOrder(1000000001L);
map.put(order1,"");
map.put(order2,"");
System.out.println(map);
}
}
再次运行输出：
{Order{orderId=1000000001}=}
我们简单看下源码（为了好理解，我只截取了重点代码）：以putorder2作为注释讲解。
finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,
booleanevict){
Node[]tab;Nodep;intn,i;
if((tab=table)==null||(n=tab.length)==0)
n=(tab=resize()).length;
//重写hashCode之后两个对象的orderId相同，hashCode也肯定相同。
//通过hash算出索引通过索引取值有值不进入if。
if((p=tab[i=(n-1)&hash])==null)
tab[i]=newNode(hash,key,value,null);
else{
Nodee;Kk;
//由于重写了hashCode旧对象的hashCode和新的肯定相等
if(p.hash==hash&&
//(k=p.key)==key==false因为比较的是对象地址
//(key!=null&&key.equals(k))==true因为重写了equalsorderId相等则相等
((k=p.key)==key||(key!=null&&key.equals(k))))
//保存旧Node
e=p;
.......
if(e!=null){//existingmappingforkey
VoldValue=e.value;
if(!onlyIfAbsent||oldValue==null)
//value覆盖旧Node的值
e.value=value;
afterNodeAccess(e);
returnoldValue;
}
}
........
}
所以order2覆盖了order1。这就是为什么当使用自定义对象作为HashMap的Key时如果重写了equals要同时hashCode。
反过来说：重写了hashCode，equals需要重写吗？
答案是要的，都要重写！
还是以上面代码重写的逻辑为例，假设hashCode相同的两个对象，且已经putorder1在put时，hash相同，得出的索引也是相同，就可以取到order1，取到之后会继续使用equals比较，假设没有重写的话，那么就是对象地址比较，结果肯定是false，那么这个时候就发生了hash碰撞，也就形成了链表。
还有在map.get(key)时也是一样都会根据hashCode找，再判断equals。
为什么要判断equals呢？因为根据hashCode找到的是一个链表，需要根据equals在链表中找到Key相等的那个值。
什么场景会用到自定义类做key？
最常见的key是一个坐标，比如说在地图的某个坐标放置一个物体之类的。
publicclassTest{
staticclassCoordinate{
publicCoordinate(intx,inty){
this.x=x;
this.y=y;
}
privateintx;
privateinty;
publicintgetX(){
returnx;
}
publicvoidsetX(intx){
this.x=x;
}
publicintgetY(){
returny;
}
publicvoidsetY(inty){
this.y=y;
}
}
publicstaticvoidmain(String[]args){
Mapmap=newHashMap<>();
map.put(newCoordinate(22,99),"手机");
map.put(newCoordinate(44,48),"电脑");
}
}
总结
到此这篇关于重写equals的同时为何要重写hashCode的文章就介绍到这了,更多相关重写equals的同时重写hashCode内容请搜索毛票票以前的文章或继续浏览下面的相关文章希望大家以后多多支持毛票票！