關于 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最全面試題及答案，

推薦去我的博客閱讀更多：

1.Java JVM、集合、多執行緒、新特性系列教程

2.Spring MVC、Spring Boot、Spring Cloud 系列教程

3.Maven、Git、Eclipse、Intellij IDEA 系列工具教程

4.Java、后端、架構、阿里巴巴等大廠最新面試題

覺得不錯，別忘了點贊+轉發哦！

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/120991.html

標籤：Java

上一篇：Java鎖_讀寫鎖

下一篇：新人報道。。求大神指導。