關於 equals 和 hashCode，看這一篇真的夠了！
作者：CringKong
https://blog.csdn.net/CringKong/article/details/89429269
這幾天在嘗試手擼一個類似Lombok的註解式程式碼生成工具，用過Lombok的小夥伴知道，Lombok可以通過註解自動幫我們生產equals()和hashCode()方法，因此我也想實現這個功能，但是隨著工作的深入，我發現其實自己對於equals()和hashCode()的理解，也處在一個很低階的階段。
因此痛定思痛，進行了一番深入學習，才敢來寫這篇部落格。
1、equals在Java中含義
首先要解釋清楚這個，equals方法在Java中代表邏輯上的相等，什麼叫邏輯上的相等？這個就涉及到Java本身的語法特性。
我們知道，Java中存在著==來判斷基本資料型別的相等，但是對於物件，==只能判斷記憶體地址是否相等，也就是說是否是同一個物件：
int a = 10000; int b = 10000; // 對於基本資料型別， == 可以判斷邏輯上的相等 System.out.println(a == b); Integer objA = 10000; Integer objB = 10000; Integer objA1 = objA; // 對於類例項， == 只能判斷是否為同一個例項（可以視為記憶體地址是否相等） System.out.println(objA == objB); System.out.println(objA == objA1);
注：這裡我們不討論Integer對於-128~127的快取機制。
結果顯而易見：
但是明明 objA和objB邏輯上是相等的，憑什麼你就返回false？這時就誕生了一種需求，對於Java中的物件，要判斷邏輯相等，該怎麼實現呢，於是就出現了**`equals()`**方法。
Integer objA = 10000;
Integer objB = 10000;
Integer objA1 = objA;
// 對於物件例項， equals 可以判斷兩個物件是否邏輯相等
System.out.println(objA.equals(objB));
Integer類已經重寫了**`equals()`**方法，所以結果也顯而易見：
因此如果我們自己建立一個類的話， 要實現判斷兩個例項邏輯上是否相等，就需要重寫他的[equals()](http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247495256&idx=1&sn=5af5a0045edcbde3b0716e83e69870b3&chksm=eb506b6edc27e27833049c20337cb99cdb1fdce00c53591b1730f42441876d8d2975de010f1a&scene=21#wechat_redirect)方法。
// 重寫了equals方法的類
staticclass GoodExample {
private String name;
privateint age;
public GoodExample(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
if (this == o) returntrue;
if (o == null || getClass() != o.getClass()) returnfalse;
GoodExample that = (GoodExample) o;
return age == that.age &&
Objects.equals(name, that.name);
}
}
// 沒有重寫euqals方法的類
staticclass BadExample {
private String nakeName;
privateint age;
public BadExample(String nakeName, int age) {
this.nakeName = nakeName;
this.age = age;
}
}
public static void main(String\[\] args) {
System.out.println(new GoodExample("Richard", 36).
equals(new GoodExample("Richard", 36)));
System.out.println(new BadExample("Richard", 36).
equals(new BadExample("Richard", 36)));
}
相信你已經知道結果是什麼了：
2、hashCode在Java中的作用
網上有很多部落格都把hashCode()和equals()混為一談，但實際上hashCode()就是他的字面意思，代表這個物件的雜湊碼。
但是為什麼JavaDoc明確的告訴我們，hashCode()和equals()要一起重寫呢？原因是因為，在Java自帶的容器HashMap和HashSet中，都需同時要用到物件的hashCode()和equals()方法來進行判斷，然後再插入刪除元素，這點我們一會再談。
那麼我們還是單獨來看hashCode()，為什麼HashMap需要用到hashCode？這個就涉及到HashMap底層的資料結構 – 散列表的原理：
HashMap底層用於儲存資料的結構其實是散列表（也叫雜湊表），散列表是通過雜湊函式將元素對映到陣列指定下標位置，在Java中，這個雜湊函式其實就是hashCode()方法。
舉個例子：
HashMap<String,GoodExample> map = new HashMap<>();
map.put("cringkong",new GoodExample("jack",10));
map.put("cricy",new GoodExample("lisa",12));
System.out.println(map.get("cricy"));
在存入HashMap的時候，HashMap會用字串"cringkong"和"cricy"的hashCode()去對映到陣列指定下標位置，至於怎麼去對映，我們一會再說。
好了，現在我們明白了hashCode()為什麼被設計出來，那麼我們來進行一個實驗：
// 科學設計了hashCode的類
staticclass GoodExample {
private String name;
privateint age;
public GoodExample(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
// 不科學的hashCode寫法
staticclass BadExample {
private String nakeName;
privateint age;
public BadExample(String nakeName, int age) {
this.nakeName = nakeName;
this.age = age;
}
@Override
public int hashCode() {
// 這裡我們沒有用
return nakeName.hashCode();
}
}
這裡我們存在兩個類，GoodExample類通過類全部欄位進行hash運算得到hashCode，而BadExample只通過類的一個欄位進行hash運算，我們來看一下得到的結果：
System.out.println(new GoodExample("李老三", 22).hashCode());
System.out.println(new GoodExample("李老三", 42).hashCode());
System.out.println(new BadExample("王老五", 50).hashCode());
System.out.println(new BadExample("王老五", 25).hashCode());
可以看到，GoodExample的hashCode()標明瞭22歲和42歲的李老三是不同的，而BadExample卻認為50歲和25歲的王老五沒什麼區別。
那麼也就是說在HashMap中，兩個李老三會被放到不同的陣列下標位置中，而兩個王老五會被放到同一個陣列下標位置上。
PS : hashCode相等的兩個物件不一定邏輯相等，邏輯相等的兩個物件hashCode必須相等！
3、為什麼hashCode和equals要一起重寫
剛剛我們知道，equals()是用來判斷物件是否邏輯相等，hashCode()就是獲得一個物件的hash值，同時再HashMap中用來得到陣列下標位置。
那麼為什麼很多地方都說到，hashCode()和equals()要一起重寫呢？明明通過物件hashCode就可以定位陣列下標了啊，那我們直接用把物件存進去取出來不就行了嗎？
答案是這樣的：設計再良好的雜湊函式，也會出現雜湊衝突的情況，什麼是雜湊衝突呢？舉個例子來說，我設計了這樣一種雜湊函式：
/**
* 硬核雜湊函式，雜湊規則是 傳入的字串的首位字元轉換成ASCII值
*
* @param string 需要雜湊的字串
* @return 字串的雜湊值
*/
private static int hardCoreHash(String string) {
return string.charAt(0);
}
我們來測試一下硬核雜湊函式的雜湊效果：
System.out.println(hardCoreHash("fish"));
System.out.println(hardCoreHash("cat"));
System.out.println(hardCoreHash("fuck"));
可以看到， "fish" 和 "fuck"出現了雜湊衝突，這是我們不想看到的，一旦出現了雜湊衝突，我們的雜湊表就需要解決雜湊衝突，一般解方式有：
-
開發定址法（線性探測再雜湊，二次探測再雜湊，偽隨機探測再雜湊）
-
再雜湊法
-
鏈地址法
-
建立一個公共溢位區
這都是資料結構課本上的東西，我就不再細講了，不懂的同學自行搜尋！
就像我之前說的，設計再精良的雜湊函式，也會有雜湊衝突的情況出現，Java中的hashCode()本身就是一種雜湊函式，必然會出現雜湊衝突，更怕一些程式設計師寫出某些硬核雜湊函式。
既然存在雜湊衝突，我們就得解決，HashMap採用的是鏈地址法來解決：(偷張圖…
這裡就存在一種極端情況，如何判斷是究竟是兩個 邏輯相等的物件重複寫入，還是兩個邏輯不等的物件出現了雜湊衝突呢？
很簡單，用equals()方法判斷不就完事了嗎，我們之前說了，equals()方法就是用來設計判斷兩個物件是否邏輯相等的啊！
我們來看一段HashCode簡單的取出key對應value的原始碼：
意思很簡單，先判斷這key的 hashCode是否相等，如果不相等，說明key和陣列中物件一定邏輯不相等，就不用再判斷了，如果相等，就繼續判斷是否邏輯相等，從而確定究竟是出現了雜湊衝突，還是確實就是要取這個key的對應的值。
所以說到這裡，你應該明白為什麼千叮嚀萬囑咐equals()和hashCode()要一塊重寫了吧。如果這個類的物件要作為HashMap的key，或者要存入HashSet，是必兩個方法都要重寫的，其他情況可以自行斟酌，但是為了安全方便不出錯，就直接一塊重寫了吧。
4、擴充套件：實現科學的雜湊函式
說的科學的雜湊函式，就不得不說經典的字串雜湊函式：DJB hash function俗稱Times33的雜湊函式：
unsigned int time33(char *str){
unsignedint hash = 5381;
while(*str){
hash += (hash << 5 ) \+ (*str++);
}
return (hash & 0x7FFFFFFF);
}
這個函式的實現思路，就是不斷地讓當前的雜湊值乘33（左移5位相當於乘上32，然後加上原值相當於乘上33），再加上字串當前位置的值（ASCII），然後雜湊值進入下一輪迭代，直到字串的最後一位，迭代完成返回雜湊值。
為什麼說他科學？因為根據實驗，這種方式的出來雜湊值分佈比較均勻，就是最小可能性出現雜湊衝突，同時計算速度也比較快。
至於初始值5381怎麼來的？也是實驗找到的比較科學的一個數。（怎麼感覺說的跟廢話一樣？）
那麼Java中的hashCode()有沒有預設實現呢？當然有：
// Object類中的hashCode函式，是一個native方法，JVM實現
public native int hashCode();
Object類作為所有類的父類，實現了native方法，是一個本地方法，JVM實現我們看不到。
而String類，則預設重寫了[`hashCode`](http://mp.weixin.qq.com/s?__biz=MzI3ODcxMzQzMw==&mid=2247491299&idx=2&sn=a0f523badfd3a1997bb89296cd78393d&chksm=eb539bd5dc2412c3304e7099328782529122564afff7ba22246df3b33aced5209de7c9df9305&scene=21#wechat_redirect)方法，我們看一下實現：
public int hashCode() {
// 初始值是0
int h = hash;
if (h == 0 && value.length > 0) {
char val\[\] = value;
// 31作為乘子，是不是應該叫Timers31呢?
for (int i = 0; i < value.length; i++) {
h = 31 \* h + val\[i\];
}
hash = h;
}
return h;
}
可以看到，Java選擇了31作為乘子，這也是有他的道理的，根據 Effective Java所說：
選擇數字31是因為它是一個奇質數，如果選擇一個偶數會在乘法運算中產生溢位，導致數值資訊丟失，因為乘二相當於移位運算。選擇質數的優勢並不是特別的明顯，但以往的雜湊演算法都這樣做。同時，數字31有一個很好的特性，即乘法運算可以被移位和減法運算取代，來獲取更好的效能：31 * i == (i << 5) - i，現代的 Java 虛擬機器可以自動的完成這個優化。
總結一下其實就是兩點原因：
-
奇質數作為雜湊運算中的乘法因子，得到的雜湊值效果比較好（分佈均勻）
-
JVM對於位運算的優化，最後選擇31是因為速度比較快
說這麼多，還是實驗出來的結果，Java開發人員認為這個數比較適合JVM平臺。
當然也有大哥做了實驗：科普：為什麼 String hashCode 方法選擇數字31作為乘子
有興趣的小夥伴可以去看看。
而且Java本身也提供了一個工具類，就是之前我用到的java.util.Objects.hash()方法，我們來下他的實現方式：
public static int hashCode(Object a\[\]) {
if (a == null)
return0;
int result = 1;
// 對於傳入的所有物件都進行一次Timers31
for (Object element : a)
// 同時用到了每個物件的hashCode()方法
result = 31 \* result + (element == null ? 0 : element.hashCode());
return result;
}
總體思路還是一樣的。
關注公眾號Java技術棧回覆"面試"獲取我整理的2020最全面試題及答案。
推薦去我的部落格閱讀更多：
2.Spring MVC、Spring Boot、Spring Cloud 系列教程
3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程
覺得不錯，別忘了點贊+轉發哦！