Java中equals和hashcode方法的來龍去脈

結繩記事，唯有記錄、思考，方能成長~

我們在開發過層中，經常用到要重寫某個對象的equals方法和hashcode方法，並且在開發規約中，也會強制“只要重寫了equals方法，就必須重寫hashcode方法”，尤其針對map的鍵及set存儲的對象。今天就梳理下equals和hashcode的來龍去脈。

一、WHY 爲什麼要重寫equals和hashcode方法

Object類是java中的萬類之祖，其中有2個重要的方法equals和hashcode，所有的子類中如果沒有重寫這2個方法的情況下，都是使用Object類的實現邏輯，我們看下它是如何實現的

/**
	* ……
     * Note that it is generally necessary to override the {@code hashCode}
     * method whenever this method is overridden, so as to maintain the
     * general contract for the {@code hashCode} method, which states
     * that equal objects must have equal hash codes.
     * 如果重寫了equals方法，非常有必要重寫hashcode方法。
     * 公約：如果equals相等的對象，hashcode也必須相等。
     * ……
*/
public boolean equals(Object obj) {
        return (this == obj);
    }

/**
* 本地方法
*/
public native int hashCode();

默認的equals方法，是嚴格判斷一個對象是否相等的方法，只有this 和 obj引用同一個對象，纔會返回TRUE；
默認的hashcode方法，是根據內存地址換算出來的一個值。

但在我們實際業務中，我們關心的並不是2個對象的內存地址相等，而是它們的屬性是否相等。所以，如此嚴格的相等，我們並不需要。

二、WHAT 重寫的規約是什麼

equals方法

關於重寫，Object類中equals方法註釋上有具體的指導原則(公約)，如下：

1. 自反性(reflexive)：x.equals(x)一定是true。自反性這個翻譯不太好，有點讓人難捉摸，總之就是自己肯定跟自己相等。
2. 對稱性(symmetric)：x.equals(y) 和 y.equals(x)結果一致。
3. 傳遞性(transitive)：a 和 b equals，b 和 c equals，則a 和 c 也一定equals。
4. 一致性(consistent)：如果對比的對象的信息沒有被修改的話，不管進行多少次對比，總能一致的返回true 或 false。
5. 空值：對於任意空值，x.equals(null)，返回結果一定是false

hashcode方法

這個方法返回對象的散列碼，返回值是int類型的散列碼。對象的散列碼是爲了更好地支持基於哈希機制的Java集合類，例如HashTable、HashMap、HashSet等。
關於重寫，Object類中的hashcode方法註釋上也有具體的指導原則(公約)，如下：

1. 在某個運行期間，只要對象的(字段的)變化不會影響equals方法的決策結果，那麼，在這個期間，無論調用多少次hashcode方法，都必須返回同一個散列碼。
2. 如果2個對象通過equals調用後返回的是true，那麼這2個對象的hashcode方法也必須返回同樣的散列碼。
3. 如果2個對象通過equals調用後返回的是false，它們的hashcode返回的值，允許相等。(這個就是我們常說的HashMap中關於Hash碰撞的場景，在hashcode相等的情況下，會放在同一個數組下標對應的鏈表中。當然，如果hash碰撞的概率越小，會讓數據分散的更均勻，從而提高集合中讀、寫的效率)

三、HOW 如何重寫

重寫equals方法

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        
        if ((obj == null) || (obj.getClass() != this.getClass())) {
            return false;
        }
        
        // 能執行到這裏，說明obj和this是同類並且非null
        Test test = (Test) obj;
        return (age == test.age) && (name == test.name || (name != null && name.equals(test.name)));
    }

Test類中有2個字段，name和age，這2個字段代表了對象的狀態，它們也用在equals方法中作爲評判的依據。

在equals方法中，首先是比較傳入的對象的引用是否和this相等，這樣做是爲了save time，節約執行時間，如果this和obj是對同一個堆對象的引用，那麼，它們一定是equals的。

接着，判斷obj是否爲null，如果爲null，一定不equals，因爲既然當前對象能夠調用equals方法，當前對象一定非null，非null和null肯定不equals。

然後，比較2個對象的運行時類，是否爲同一個類。不是同一個類，則不equals。

最後，判斷2個對象中的屬性是否相等。當然，這裏並不一定要判斷所有字段，只需要判斷我們業務上能夠用來區分對象的屬性即可。

有些人會用下面的第二種方式來代替運行時類的比較，應該避免這樣做。

        // 第一種方式
        if ((obj == null) || (obj.getClass() != this.getClass())) {
            return false;
        }
        
        // 第二種方式，應該避免
        if (!(obj instanceof Test)) {
            return false;
        }

它違背了公約中的對稱性原則。
例如：假設Student 繼承了 Person類。那麼：
Student.equals(Person) 爲true。
Person.equals(Student) 爲false。
所以針對子類繼承父類的場景下，這種判斷方式是有問題的，因而應該從根本上避免這種寫法。

重寫hashcode方法

重寫hashcode方法注意事項：

1. 2個對象相等，那麼它們的hashcode一定相等，所以參與到equals函數的字段，也必須參與hashcode函數的計算。
2. 最終的hash是個int值，要防止數值溢出。
3. 不同對象的hash碼儘量不同，避免hash衝突。

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 31 * hash + age;
        hash = 31 * hash + name.hashCode();
        return hash;
    }

四、Sting類中equals、hashcode方法

public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        // 1.根據instance判斷運行類
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                // 2.根據每一個元素進行比對
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
}
    
public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;
			// 3. 根據每一個元素計算hash，即`s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]`
            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
}

我們會發現：

1. 在equals方法中，使用了我們上文提倡避免的instance方法，爲什麼在String類中就可以這樣做呢？因爲String類是個final類，它是不允許被繼承的，所以就不會存在對稱性問題。
2. hashcode方法中，計算涉及到的元素，跟equals中涉及到的元素一致的。從而保證了equals相等的元素，hashcode一定相等。

五、HashMap中的equals和hashcode

// put方法
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

// hash的計算方法
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

// 計算數組下標(根據hashcode和數組長度取模，得到數組下標)
i = (n - 1) & hash

// 判斷是否相等
// p是HashMap數組中的元素
// key是新加入元素的key， hash是新加入元素的key的hash值
if (p.hash == hash &&  ((k = p.key) == key || (key != null && key.equals(k)))) {
	// 新值替換舊值
}

可以看到hashMap中是根據hashcode和equals來判斷元素是否相等，這也是我們要重寫這2個方法的原因。