equals和hashCode的關係

要搞清楚題目中的問題就必須搞明白equals方法和hashCode方法分別是什麼，和誕生的原因，當搞明白了這一點其實題目就不算是個問題了，下面我們來探討分別探討一下兩者代表的意義。

hashCode

筆者看到很多地方都對hashCode有兩個誤解

• 物件預設的hashCode是物件的地址。
• 預設的equals會先比較物件的hashCode，如果hashCode相同則代表兩個物件是同一個物件。

在這裡筆者先給出這兩個問題的結論，後面會給出證明。

1. hashCode並不是物件的地址。
2. 預設的equals比較的是物件的地址，與hashCode無關。

事實上想求證hashCode是不是物件的地址這件事情說容易也容易，說難也難。其實筆者在網上有很多不知出處與權威性的文章都寫hashCode就是物件的地址，從這點上來說，想找到真實答案也挺不容易的，“謊言重複千遍便是真理”說的大概就是這個意思。之所以說容易是因為只要通過閱讀Oracle的JavaAPI註釋便可知道正確答案，所以其實學習一個東西最好的辦法還是看官方的文件。但因為Oracle的API是英文的，對母語不是英文的我們來說或許會有些痛苦，即時你能看懂英文文件，為了容易我們也可能選擇找中文的文章來看，不幸的是大多數軟體的文件沒有中文的。

OracleAPI中對hashCode()的註釋如下：

1. Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by HashMap.
2. As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer
   , but this implementation technique is not required by the JavaTM programming language.)

第2句話的意思是說，不同的Object物件的返回不同的hashCode，這通常通過將物件地址進行某種轉換對映為一個integer，但並不限制具體的實現方法。換句話說，hashCode的生成策略是由jdk的實現決定的。這已經能夠說明hashCode並不等於物件的實體地址，雖然實現方式與其有關，但絕不意味著相等。其實通過下面的程式碼我們也可以從某種程度上推測證明兩者並不嚴格相等。

public class B {
    public static void main(String[] args) {
        B b1 = new B();
        B b2 = new B();
        System.out.println(b1.hashCode());
        System.out.println(b2.hashCode());
    }
}
> 356573597
> 1735600054

這個程式碼非常簡單，從一開始啟動虛擬機器到b1和b2的記憶體分配之間並沒有任何其他的過多幹擾，換句話說，堆記憶體的空閒是很多的，並不存在記憶體分配中的指標碰撞或者需要維護不連續的記憶體空閒列表，因此b1和b2的記憶體分配是相當連續的。如果hashCode代表著記憶體地址，那麼兩者應該相差不大，但事實上兩者看不出任何記憶體分佈上的聯絡。

在來解釋第一句話，這句話的意思是說一些基於hash的資料結構如HashMap等會受益於此方法，這就可以做出推測，hashCode的出現是為一些基於hash的資料結構服務的。後面我們會分析HashMap是如何根據hashCode去提升效能的，這裡必須提到JVM的一個細節：java物件在記憶體分配之後，hashCode存在於物件頭中，但這個值並不是記憶體分配完成之後就有的，當第一次呼叫物件的hashCode方法，物件的hashCode值就會存放在物件頭中。

至此，關於hashCode的第一個誤解已經解決了，下面我們證明第二個，來看下面的程式碼。

public class B {
    @Override
    public int hashCode() {
        return 1;
    }
    public static void main(String[] args) {
        B b1 = new B();
        B b2 = new B();
        System.out.println(b1.equals(b2));
        System.out.println(b1 == b2);
    }
}
> false
> false

如上所示，b1和b2擁有相同的hashCode，但是不管是equals還是==比較，都返回了false，這至少證明了Object的equals方法與hashCode並無任何關聯，檢視Object的equals方法原始碼便知。

public class Object {
    public boolean equals(Object obj) {
        return (this == obj);
    }
}

equals

equals比hashCode好理解的多，它的設計初衷是為了讓程式設計人員自己定義兩個物件是否相等，這與地址無關。因為對於java虛擬機器來講，只有兩個引用指向同一個物件，兩個物件才能看作是相等的。當然，這個原因也不是筆者憑空猜測的，OracleAPI中有這兩句話如下：

public boolean equals(Object obj)
Indicates whether some other object is “equal to” this one.
The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).

但其實下面還有一句話如下：

Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.

這句話告訴我們當一個物件的hashCode方法被重寫的時候，為了保持hashCode的常規協定，建議重寫hashCode方法，這裡所指的hashCode常規協定如下：

If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.

這條contract告訴我們，如果兩個物件equals，則他們要有相同的hashCode，這並不是必須滿足的條件，事實上我們很可能經常不遵守這個協定，比如下面的程式碼：

public class B {
    @Override
    public boolean equals(Object obj) {
        return true;
    }
    public static void main(String[] args) {
        B b1 = new B();
        B b2 = new B();
        System.out.println(b1.equals(b2));
        System.out.println(b1.hashCode() == b2.hashCode());
    }
}

既然這個協定不是必須要遵守的，為什麼Java建議我們如果重寫了equals方法就要重寫hashCode方法，還告訴我們如果兩個物件equals要有相同的hashCode呢?

equals & hashCode & HashSet

前文提到，Java中的hashCode主要是為了一些使用hash的資料結構而存在的。這裡以HashSet舉例，Set中是不允許物件有重複的，這裡的重複就是相等的元素，注意：這裡要分是兩個元素是實體地址上的相等，還是通過equals比較的相等。從邏輯上來說，如果兩個元素被使用者定義了的equals方法比較的結果為true，那麼不管兩個物件hashCode值是否相等，它們能應該被定義為“重複”，但事實上如果不重寫hashCode，兩個equals的物件輸出的hashCode不同，它仍然被當作不同的元素被HashSet, HashMap等一系列hash的資料結構對待。

public class B {
    @Override
    public boolean equals(Object obj) {
        return true;
    }
    public static void main(String[] args) {
        B b1 = new B();
        B b2 = new B();
        HashSet<Object> set = new HashSet();
        set.add(b1);
        set.add(b2);
        System.out.println(set.size());
    }
}
> 2

以上程式碼set中的元素為兩個，儘管b1.equals(b2) = true這在邏輯上就與元素存放不同物件相違背了（這裡以HashSet舉例，實際上任何類似的使用hash的資料結構都可以如此推導），因此Java告訴我們，如果重寫了equals方法，請務必重寫hashCode方法，使得兩個equals的物件擁有相同的hashCode，可以被hash的集合類當作相同的元素看待。

我們順便來看一下set.add(E e)方法的內容：

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

這裡呼叫了HashMap的put方法(HashSet就是用HashMap實現的)，我們繼續跟進去：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 先比較hash, 在比較地址，最後呼叫equals
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            ....
        }
        if (e != null) { // existing mapping for key
            ....
        }
    }
    ...
}

需要說明的是這裡的hash並不是物件的hashCode，而是通過下面的方式處理後的結果

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

但由於相同的輸入有相同的輸出，這裡姑且把hash當作hashCode處理，當hashSet呼叫add方法時，會判斷HashMap中hash對應的bucket中是否有元素，如果有，判斷兩個元素的hash值是否相同，如果不同，HashMap會直接當作不同（邏輯上的）的元素處理，如果相同，還會比較equals和地址是否相同來判定該物件是否真的相同。

邏輯聽起來好像有點繞，簡單來說就是HashMap認為，如果兩個物件hashCode不同，那這兩個物件就不相等，如果hashCode相同，則根據地址和equals判定。

綜上所述，正式因為這些基於hash的資料結構，才使得我們在重寫equals時要重寫hashCode，否則在這些集合類中關於兩個物件是否相等的判定會在語義上變得不嚴謹，除此之外，equals和hashCode再無任何關聯。