如何重寫hashCode()和equals()方法

轉載：http://blog.csdn.net/neosmith/article/details/17068365

hashCode()和equals()方法可以說是Java完全面向對象的一大特色．它爲我們的編程提供便利的同時也帶來了很多危險．這篇文章我們就討論一下如何正解理解和使用這２個方法．

https://blog.csdn.net/u012767369/article/details/79362752

如何重寫equals()方法

如果你決定要重寫equals()方法，那麼你一定要明確這麼做所帶來的風險，並確保自己能寫出一個健壯的equals()方法．一定要注意的一點是，在重寫equals()後，一定要重寫hashCode()方法．具體原因稍候再進行說明．

我們先看看 JavaSE 7 Specification中對equals()方法的說明：

• It is reflexive: for any non-null reference value x, x.equals(x) should return true.
• It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
• It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
• For any non-null reference value x, x.equals(null) should return false.

這段話用了很多離散數學中的術數．簡單說明一下：

1. 自反性：A.equals(A)要返回true.

2. 對稱性：如果A.equals(B)返回true, 則B.equals(A)也要返回true.

3. 傳遞性：如果A.equals(B)爲true, B.equals(C)爲true, 則A.equals(C)也要爲true. 說白了就是 A = B , B = C , 那麼A = C.

4. 一致性：只要A,B對象的狀態沒有改變，A.equals(B)必須始終返回true.

5. A.equals(null) 要返回false.

 

相信只要不是專業研究數學的人，都對上面的東西不來電．在實際應用中我們只需要按照一定的步驟重寫equals()方法就可以了．爲了說明方便，我們先定義一個程序員類(Coder):

[java] view plain copy

1. class Coder {  
2.     private String name;  
3.     private int age;  
4.       
5.     // getters and setters  
6. }  

我們想要的是，如果２個程序員對象的name和age都是相同的，那麼我們就認爲這兩個程序員是一個人．這時候我們就要重寫其equals()方法．因爲默認的equals()實際是判斷兩個引用是否指向內在中的同一個對象，相當於 == ．　重寫時要遵循以下三步：

1. 判斷是否等於自身.

[java] view plain copy

1. if(other == this)  
2.             return true;  

2. 使用instanceof運算符判斷 other 是否爲Coder類型的對象.[java] view plain copy

1. if(!(other instanceof Coder))  
2.             return false;  

3. 比較Coder類中你自定義的數據域，name和age，一個都不能少.[java] view plain copy

1. Coder o = (Coder)other;  
2.         return o.name.equals(name) && o.age == age;  

看到這有人可能會問，第3步中有一個強制轉換，如果有人將一個Integer類的對象傳到了這個equals中，那麼會不會扔ClassCastException呢？這個擔心其實是多餘的．因爲我們在第二步中已經進行了instanceof 的判斷，如果other是非Coder對象，甚至other是個null, 那麼在這一步中都會直接返回false, 從而後面的代碼得不到執行的機會．

上面的三步也是＜Effective Java＞中推薦的步驟，基本可保證萬無一失．

 

 

如何重寫hashCode()方法

在JavaSE 7 Specification中指出，

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

 

如果你重寫了equals()方法，那麼一定要記得重寫hashCode()方法．我們在大學計算機數據結構課程中都已經學過哈希表(hash table)了，hashCode()方法就是爲哈希表服務的．

當我們在使用形如HashMap, HashSet這樣前面以Hash開頭的集合類時，hashCode()就會被隱式調用以來創建哈希映射關係．稍後我們再對此進行說明．這裏我們先重點關注一下hashCode()方法的寫法．

 

＜Effective Java＞中給出了一個能最大程度上避免哈希衝突的寫法，但我個人認爲對於一般的應用來說沒有必要搞的這麼麻煩．如果你的應用中HashSet中需要存放上萬上百萬個對象時，那你應該嚴格遵循書中給定的方法．如果是寫一箇中小型的應用，那麼下面的原則就已經足夠使用了：

要保證Coder對象中所有的成員都能在hashCode中得到體現．

對於本例，我們可以這麼寫：

[java] view plain copy

1. @Override  
2.     public int hashCode() {  
3.         int result = 17;  
4.         result = result * 31 + name.hashCode();  
5.         result = result * 31 + age;  
6.           
7.         return result;  
8.     }  

其中int result = 17你也可以改成20, 50等等都可以．看到這裏我突然有些好奇，想看一下String類中的hashCode()方法是如何實現的．查文檔知：

 

"Returns a hash code for this string. The hash code for a String object is computed as

 s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
 

using int arithmetic, where s[i] is the ith character of the string, n is the length of the string, and ^ indicates exponentiation. (The hash value of the empty string is zero.)"

對每個字符的ASCII碼計算n - 1次方然後再進行加和，可見Sun對hashCode的實現是很嚴謹的. 這樣能最大程度避免２個不同的String會出現相同的hashCode的情況．

 

重寫equals()而不重寫hashCode()的風險

在Oracle的Hash Table實現中引用了bucket的概念．如下圖所示：

 

從上圖中可以看出，帶bucket的hash table大致相當於哈希表與鏈表的結合體．即在每個bucket上會掛一個鏈表，鏈表的每個結點都用來存放對象．Java通過hashCode()方法來確定某個對象應該位於哪個bucket中，然後在相應的鏈表中進行查找．在理想情況下，如果你的hashCode()方法寫的足夠健壯，那麼每個bucket將會只有一個結點，這樣就實現了查找操作的常量級的時間複雜度．即無論你的對象放在哪片內存中，我都可以通過hashCode()立刻定位到該區域，而不需要從頭到尾進行遍歷查找．這也是哈希表的最主要的應用．

 

如：

當我們調用HashSet的put(Object o)方法時，首先會根據o.hashCode()的返回值定位到相應的bucket中，如果該bucket中沒有結點，則將 o 放到這裏，如果已經有結點了, 則把 o 掛到鏈表末端．同理，當調用contains(Object o)時，Java會通過hashCode()的返回值定位到相應的bucket中，然後再在對應的鏈表中的結點依次調用equals()方法來判斷結點中的對象是否是你想要的對象．

 

下面我們通過一個例子來體會一下這個過程：

我們先創建２個新的Coder對象：

[java] view plain copy

1. Coder c1 = new Coder("bruce", 10);  
2.         Coder c2 = new Coder("bruce", 10);  

假定我們已經重寫了Coder的equals()方法而沒有重寫hashCode()方法：[java] view plain copy

1. @Override  
2.     public boolean equals(Object other) {  
3.         System.out.println("equals method invoked!");  
4.           
5.         if(other == this)  
6.             return true;  
7.         if(!(other instanceof Coder))  
8.             return false;  
9.           
10.         Coder o = (Coder)other;  
11.         return o.name.equals(name) && o.age == age;  
12.     }  

然後我們構造一個HashSet，將c1對象放入到set中：[java] view plain copy

1. Set<Coder> set = new HashSet<Coder>();  
2.         set.add(c1);  

再執行：[java] view plain copy

1. System.out.println(set.contains(c2));  

 

我們期望contains(c2)方法返回true, 但實際上它返回了false.

c1和c2的name和age都是相同的，爲什麼我把c1放到HashSet中後，再調用contains(c2)卻返回false呢？這就是hashCode()在作怪了．因爲你沒有重寫hashCode()方法，所以HashSet在查找c2時，會在不同的bucket中查找．比如c1放到05這個bucket中了，在查找c2時卻在06這個bucket中找，這樣當然找不到了．因此，我們重寫hashCode()的目的在於，在A.equals(B)返回true的情況下，A, B 的hashCode()要返回相同的值．

 

我讓hashCode()每次都返回一個固定的數行嗎

有人可能會這樣重寫：

[java] view plain copy

1. @Override  
2.     public int hashCode() {  
3.         return 10;  
4.   
5.     }  

如果這樣的話，HashMap, HashSet等集合類就失去了其 "哈希的意義"．用<Effective Java>中的話來說就是，哈希表退化成了鏈表．如果hashCode()每次都返回相同的數，那麼所有的對象都會被放到同一個bucket中，每次執行查找操作都會遍歷鏈表，這樣就完全失去了哈希的作用．所以我們最好還是提供一個健壯的hashCode()爲妙．