這幾天在嘗試手?jǐn)]一個(gè)類似Lombok的注解式代碼生成工具，用過(guò)Lombok的小伙伴知道，Lombok可以通過(guò)注解自動(dòng)幫我們生產(chǎn)equals()和hashCode()方法，因此我也想實(shí)現(xiàn)這個(gè)功能，但是隨著工作的深入，我發(fā)現(xiàn)其實(shí)自己對(duì)于equals()和hashCode()的理解，也處在一個(gè)很低級(jí)的階段。

因此痛定思痛，進(jìn)行了一番深入學(xué)習(xí)，才敢來(lái)寫(xiě)這篇博客。

1、equals在Java中含義

首先要解釋清楚這個(gè)，equals方法在Java中代表邏輯上的相等，什么叫邏輯上的相等？這個(gè)就涉及到Java本身的語(yǔ)法特性。

我們知道，Java中存在著==來(lái)判斷基本數(shù)據(jù)類型的相等，但是對(duì)于對(duì)象，==只能判斷內(nèi)存地址是否相等，也就是說(shuō)是否是同一個(gè)對(duì)象： 

int a = 10000;  
int b = 10000;  
// 對(duì)于基本數(shù)據(jù)類型， == 可以判斷邏輯上的相等  
System.out.println(a == b);  
Integer objA = 10000;  
Integer objB = 10000;  
Integer objAobjA1 = objA;  
// 對(duì)于類實(shí)例， == 只能判斷是否為同一個(gè)實(shí)例（可以視為內(nèi)存地址是否相等）  
System.out.println(objA == objB);  
System.out.println(objA == objA1); 

注：這里我們不討論Integer對(duì)于-128~127的緩存機(jī)制。

結(jié)果顯而易見(jiàn)：

但是明明 objA和objB邏輯上是相等的，憑什么你就返回false？這時(shí)就誕生了一種需求，對(duì)于Java中的對(duì)象，要判斷邏輯相等，該怎么實(shí)現(xiàn)呢，于是就出現(xiàn)了equals()方法。 

Integer objA = 10000;  
Integer objB = 10000;  
Integer objAobjA1 = objA;  
// 對(duì)于對(duì)象實(shí)例， equals 可以判斷兩個(gè)對(duì)象是否邏輯相等  
       System.out.println(objA.equals(objB)); 

Integer類已經(jīng)重寫(xiě)了equals()方法，所以結(jié)果也顯而易見(jiàn)：

因此如果我們自己創(chuàng)建一個(gè)類的話， 要實(shí)現(xiàn)判斷兩個(gè)實(shí)例邏輯上是否相等，就需要重寫(xiě)他的equals()方法。 

// 重寫(xiě)了equals方法的類  
static class GoodExample {  
    private String name;  
    private int age;  
    public GoodExample(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
    @Override  
    public boolean equals(Object o) {  
        if (this == o) return true;  
        if (o == null || getClass() != o.getClass()) return false;  
        GoodExample that = (GoodExample) o;  
        return age == that.age &&  
                Objects.equals(name, that.name);  
    }  
}  
// 沒(méi)有重寫(xiě)euqals方法的類  
static class BadExample {  
    private String nakeName; 
     private int 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)));  
} 

相信你已經(jīng)知道結(jié)果是什么了：

2、hashCode在Java中的作用

網(wǎng)上有很多博客都把hashCode()和equals()混為一談，但實(shí)際上hashCode()就是他的字面意思，代表這個(gè)對(duì)象的哈希碼。

但是為什么JavaDoc明確的告訴我們，hashCode()和equals()要一起重寫(xiě)呢？原因是因?yàn)?，在Java自帶的容器HashMap和HashSet中，都需同時(shí)要用到對(duì)象的hashCode()和equals()方法來(lái)進(jìn)行判斷，然后再插入刪除元素，這點(diǎn)我們一會(huì)再談。

那么我們還是單獨(dú)來(lái)看hashCode()，為什么HashMap需要用到hashCode？這個(gè)就涉及到HashMap底層的數(shù)據(jù)結(jié)構(gòu) – 散列表的原理：

HashMap底層用于存儲(chǔ)數(shù)據(jù)的結(jié)構(gòu)其實(shí)是散列表（也叫哈希表），散列表是通過(guò)哈希函數(shù)將元素映射到數(shù)組指定下標(biāo)位置，在Java中，這個(gè)哈希函數(shù)其實(shí)就是hashCode()方法。

舉個(gè)例子： 

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的時(shí)候，HashMap會(huì)用字符串"cringkong"和"cricy"的hashCode()去映射到數(shù)組指定下標(biāo)位置，至于怎么去映射，我們一會(huì)再說(shuō)。

好了，現(xiàn)在我們明白了hashCode()為什么被設(shè)計(jì)出來(lái)，那么我們來(lái)進(jìn)行一個(gè)實(shí)驗(yàn)： 

// 科學(xué)設(shè)計(jì)了hashCode的類  
static class GoodExample {  
    private String name;  
    private int age;  
    public GoodExample(String name, int age) {  
        this.name = name;  
        this.age = age;  
    }  
    @Override  
    public int hashCode() {  
        return Objects.hash(name, age);  
    }  
}  
// 不科學(xué)的hashCode寫(xiě)法  
static class BadExample {  
    private String nakeName;  
    private int age;  
    public BadExample(String nakeName, int age) {  
        this.nakeName = nakeName;  
        this.age = age;  
    }  
    @Override  
    public int hashCode() {  
        // 這里我們沒(méi)有用  
        return nakeName.hashCode();  
    }  
} 

這里我們存在兩個(gè)類，GoodExample類通過(guò)類全部字段進(jìn)行hash運(yùn)算得到hashCode，而B(niǎo)adExample只通過(guò)類的一個(gè)字段進(jìn)行hash運(yùn)算，我們來(lái)看一下得到的結(jié)果： 

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()標(biāo)明了22歲和42歲的李老三是不同的，而B(niǎo)adExample卻認(rèn)為50歲和25歲的王老五沒(méi)什么區(qū)別。

那么也就是說(shuō)在HashMap中，兩個(gè)李老三會(huì)被放到不同的數(shù)組下標(biāo)位置中，而兩個(gè)王老五會(huì)被放到同一個(gè)數(shù)組下標(biāo)位置上。

PS : hashCode相等的兩個(gè)對(duì)象不一定邏輯相等，邏輯相等的兩個(gè)對(duì)象hashCode必須相等！

3、為什么hashCode和equals要一起重寫(xiě)

剛剛我們知道，equals()是用來(lái)判斷對(duì)象是否邏輯相等，hashCode()就是獲得一個(gè)對(duì)象的hash值，同時(shí)再HashMap中用來(lái)得到數(shù)組下標(biāo)位置。

那么為什么很多地方都說(shuō)到，hashCode()和equals()要一起重寫(xiě)呢？明明通過(guò)對(duì)象hashCode就可以定位數(shù)組下標(biāo)了啊，那我們直接用把對(duì)象存進(jìn)去取出來(lái)不就行了嗎？

答案是這樣的：設(shè)計(jì)再良好的哈希函數(shù)，也會(huì)出現(xiàn)哈希沖突的情況，什么是哈希沖突呢？舉個(gè)例子來(lái)說(shuō)，我設(shè)計(jì)了這樣一種哈希函數(shù)：    

/**  
         * 硬核哈希函數(shù)，哈希規(guī)則是 傳入的字符串的首位字符轉(zhuǎn)換成ASCII值  
         *  
         * @param string 需要哈希的字符串  
         * @return 字符串的哈希值  
         */  
        private static int hardCoreHash(String string) {  
            return string.charAt(0);  
        } 

我們來(lái)測(cè)試一下硬核哈希函數(shù)的哈希效果： 

System.out.println(hardCoreHash("fish"));  
System.out.println(hardCoreHash("cat")); 
System.out.println(hardCoreHash("fuck")); 

可以看到， "fish" 和 "fuck"出現(xiàn)了哈希沖突，這是我們不想看到的，一旦出現(xiàn)了哈希沖突，我們的哈希表就需要解決哈希沖突，一般解方式有：

•  開(kāi)發(fā)定址法（線性探測(cè)再散列，二次探測(cè)再散列，偽隨機(jī)探測(cè)再散列）
•  再哈希法
•  鏈地址法
•  建立一個(gè)公共溢出區(qū)

這都是數(shù)據(jù)結(jié)構(gòu)課本上的東西，我就不再細(xì)講了，不懂的同學(xué)自行搜索！

就像我之前說(shuō)的，設(shè)計(jì)再精良的哈希函數(shù)，也會(huì)有哈希沖突的情況出現(xiàn)，Java中的hashCode()本身就是一種哈希函數(shù)，必然會(huì)出現(xiàn)哈希沖突，更怕一些程序員寫(xiě)出某些硬核哈希函數(shù)。

既然存在哈希沖突，我們就得解決，HashMap采用的是鏈地址法來(lái)解決：(偷張圖…

這里就存在一種極端情況，如何判斷是究竟是兩個(gè) 邏輯相等的對(duì)象重復(fù)寫(xiě)入，還是兩個(gè)邏輯不等的對(duì)象出現(xiàn)了哈希沖突呢？

很簡(jiǎn)單，用equals()方法判斷不就完事了嗎，我們之前說(shuō)了，equals()方法就是用來(lái)設(shè)計(jì)判斷兩個(gè)對(duì)象是否邏輯相等的??！

我們來(lái)看一段HashCode簡(jiǎn)單的取出key對(duì)應(yīng)value的源碼：

意思很簡(jiǎn)單，先判斷這key的 hashCode是否相等，如果不相等，說(shuō)明key和數(shù)組中對(duì)象一定邏輯不相等，就不用再判斷了，如果相等，就繼續(xù)判斷是否邏輯相等，從而確定究竟是出現(xiàn)了哈希沖突，還是確實(shí)就是要取這個(gè)key的對(duì)應(yīng)的值。

所以說(shuō)到這里，你應(yīng)該明白為什么千叮嚀萬(wàn)囑咐equals()和hashCode()要一塊重寫(xiě)了吧。如果這個(gè)類的對(duì)象要作為HashMap的key，或者要存入HashSet，是必兩個(gè)方法都要重寫(xiě)的，其他情況可以自行斟酌，但是為了安全方便不出錯(cuò)，就直接一塊重寫(xiě)了吧。

4、擴(kuò)展：實(shí)現(xiàn)科學(xué)的哈希函數(shù)

說(shuō)的科學(xué)的哈希函數(shù)，就不得不說(shuō)經(jīng)典的字符串哈希函數(shù)：DJB hash function俗稱Times33的哈希函數(shù)： 

unsigned int time33(char *str){  
    unsigned int hash = 5381;  
    while(*str){  
        hash += (hash << 5 ) + (*str++);  
    }  
    return (hash & 0x7FFFFFFF);  
} 

這個(gè)函數(shù)的實(shí)現(xiàn)思路，就是不斷地讓當(dāng)前的哈希值乘33（左移5位相當(dāng)于乘上32，然后加上原值相當(dāng)于乘上33），再加上字符串當(dāng)前位置的值（ASCII），然后哈希值進(jìn)入下一輪迭代，直到字符串的最后一位，迭代完成返回哈希值。

為什么說(shuō)他科學(xué)？因?yàn)楦鶕?jù)實(shí)驗(yàn)，這種方式的出來(lái)哈希值分布比較均勻，就是最小可能性出現(xiàn)哈希沖突，同時(shí)計(jì)算速度也比較快。

至于初始值5381怎么來(lái)的？也是實(shí)驗(yàn)找到的比較科學(xué)的一個(gè)數(shù)。（怎么感覺(jué)說(shuō)的跟廢話一樣？）

那么Java中的hashCode()有沒(méi)有默認(rèn)實(shí)現(xiàn)呢？當(dāng)然有： 

// Object類中的hashCode函數(shù)，是一個(gè)native方法，JVM實(shí)現(xiàn)  
public native int hashCode(); 

Object類作為所有類的父類，實(shí)現(xiàn)了native方法，是一個(gè)本地方法，JVM實(shí)現(xiàn)我們看不到。

而String類，則默認(rèn)重寫(xiě)了hashCode方法，我們看一下實(shí)現(xiàn)：  

public int hashCode() {  
    // 初始值是0  
     int h = hash;  
     if (h == 0 && value.length > 0) {  
         char val[] = value;  
        // 31作為乘子，是不是應(yīng)該叫Timers31呢?  
         for (int i = 0; i < value.length; i++) {  
             h = 31 * h + val[i];  
         }  
         hhash = h;  
     }  
     return h;  
 } 

可以看到，Java選擇了31作為乘子，這也是有他的道理的，根據(jù) Effective Java所說(shuō)：

選擇數(shù)字31是因?yàn)樗且粋€(gè)奇質(zhì)數(shù)，如果選擇一個(gè)偶數(shù)會(huì)在乘法運(yùn)算中產(chǎn)生溢出，導(dǎo)致數(shù)值信息丟失，因?yàn)槌硕喈?dāng)于移位運(yùn)算。選擇質(zhì)數(shù)的優(yōu)勢(shì)并不是特別的明顯，但以往的哈希算法都這樣做。同時(shí)，數(shù)字31有一個(gè)很好的特性，即乘法運(yùn)算可以被移位和減法運(yùn)算取代，來(lái)獲取更好的性能：31 * i == (i << 5) - i，現(xiàn)代的 Java 虛擬機(jī)可以自動(dòng)的完成這個(gè)優(yōu)化。

總結(jié)一下其實(shí)就是兩點(diǎn)原因：

1.  奇質(zhì)數(shù)作為哈希運(yùn)算中的乘法因子，得到的哈希值效果比較好（分布均勻）
2.  JVM對(duì)于位運(yùn)算的優(yōu)化，最后選擇31是因?yàn)樗俣缺容^快

說(shuō)這么多，還是實(shí)驗(yàn)出來(lái)的結(jié)果，Java開(kāi)發(fā)人員認(rèn)為這個(gè)數(shù)比較適合JVM平臺(tái)。

當(dāng)然也有大哥做了實(shí)驗(yàn)：科普：為什么 String hashCode 方法選擇數(shù)字31作為乘子

有興趣的小伙伴可以去看看。

而且Java本身也提供了一個(gè)工具類，就是之前我用到的java.util.Objects.hash()方法，我們來(lái)下他的實(shí)現(xiàn)方式： 

public static int hashCode(Object a[]) {  
    if (a == null)  
        return 0;  
    int result = 1;  
    // 對(duì)于傳入的所有對(duì)象都進(jìn)行一次Timers31  
    for (Object element : a)  
        // 同時(shí)用到了每個(gè)對(duì)象的hashCode()方法  
        result = 31 * result + (element == null ? 0 : element.hashCode());  
    return result;  
} 

總體思路還是一樣的。