文章目錄

• 一、前言
• 二、hashCode()方法
• 三、equals()方法
• 四、hashCode() 與 equals()
• • 4.1 不會創建“類對應的散列表”的情況
  • 4.2 會創建“類對應的散列表”的情況
  • • 4.2.1 Set無法去重問題
    • 4.2.2 哈希沖突問題
    • 4.2.3 equals()和hashCode()完全對應
    • 4.2.4 進一步解釋為什么重寫equals()就要重寫hashCode()
• 五、重寫hashCode()的目標
• 六、面試金手指
• • 6.1 為什么重寫equals()一定要重寫hashCode()
  • • 6.1.1 不會創建“類對應的散列表”的情況
    • 6.1.2 創建“類對應的散列表”的情況下
  • 6.2 hashCode()底層實現，一個好的哈希算法
• 七、尾聲

一、前言

二、hashCode()方法

hashCode() 方法：
(1) 作用：用于判斷兩個對象是否相等；
(2) 實現：通過獲取到的哈希碼來確定該對象在哈希表中的索引位置，哈希碼也稱散列碼，實際上就是返回一個int整數；
(3) Object類：hashCode() 定義在JDK的Object.java中，這就意味著Java中的任何類都包含有hashCode() 函數，并且通過調用hashCode()方法獲取對象的hash值。

舉個例子

public class DemoTest {?public static void main(String[] args) {Object obj = new Object();System.out.println(obj.hashCode());} }

這段代碼中，obj引用就是通過調用hashCode()方法來獲取對象的hash值。

三、equals()方法

equals()方法：
(1) 作用：用于判斷兩個對象是否相等；
(2) 實現：如果對象重寫了equals()方法，重寫的比較邏輯一般是比較兩個對象的內容是否相等；如果沒有重寫，那就是比較兩個對象的地址是否相同，等價于“==”；
(3) Object類：equals()定義在JDK的Object.java中，這就意味著Java中的任何類都包含有equals()函數，并且通過調用equals()方法比較兩個引用相等，引用復制就相等，淺復制和深復制都不相等。

舉個例子

public class DemoTest {?public static void main(String[] args) {Object obj = new Object();System.out.println(obj.equals(obj));} }

這段代碼中，obj引用就是通過調用equals()方法來比較對象引用的。

四、hashCode() 與 equals()

接下面，我們討論另外一個話題——hashCode() 和 equals() 這兩個方法有什么關系？為什么重寫equals就要重寫hashcode?

4.1 不會創建“類對應的散列表”的情況

不會創建“類對應的散列表”的情況下，
(1) hashCode()：hashCode()除了打印引用所指向的對象地址看一看，沒有任何調用，重寫hashCode()邏輯也沒有用，反正沒有調用；
(2) equals()：equals()用來比較，可以自定義比較邏輯；
(3) 關系：hashCode()和equals()是兩個獨立方法，沒有任何關系，所以不存在重寫equals()要重寫hashCode()。

這里所說的“不會創建類對應的散列表”是說：我們不會在HashSet, HashTable, HashMap等這些本質是散列表的數據結構中使用該類作為泛型。在這種情況下，該類的“hashCode() 和 equals() ”沒有半毛錢關系。

小結：當我們不在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中用到這個類，此時，equals() 用來比較該類的兩個對象是否相等，而hashCode() 則根本沒有任何作用，所以，不用理會hashCode()。

舉個例子

class Main2cumtomzieEquals {public static void main(String[] args) {Person p1 = new Person("eee", 100);Person p2 = new Person("eee", 100);Person p3 = new Person("aaa", 200);System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());System.out.printf("p1.equals(p3) : %s; p1(%d) p3(%d)\n", p1.equals(p3), p1.hashCode(), p3.hashCode());}private static class Person {private String name;private int age;public Person(String name, int age) {super();this.name = name;this.age = age;}/*** 重寫equals方法*/@Overridepublic boolean equals(Object obj) {if (obj == null) {return false;}// 如果是同一個對象返回true，反之返回falseif (this == obj) {return true; // 引用相同，返回為true}// 判斷是否類型相同if (this.getClass() != obj.getClass()) {return false; // getClass() 不相同，為false}Person person = (Person) obj; // 引用賦值return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同}} }

運行結果：

p1.equals(p2) : true; p1(2133927002) p2(1836019240) p1.equals(p3) : false; p1(2133927002) p3(1625635731)

這段程序證明：對于當我們不在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中用到這個類作為泛型，此時，這個類的hashCode() 和 equals()沒有任何關系，在p1和p2使用equals()比較相等的情況下，hashCode()也不一定相等。

小結：不會創建“類對應的散列表”的情況下，
對于hashCode()：默認hashCode()僅僅返回一個int型哈希值，但是這個返回的哈希值沒卵用；
對于equals()：默認的equals)比較兩個引用是否相等，而我們自己重寫的equals用來比較兩類的屬性是否相等，因為引用賦值，所有最后兩個屬性int string一定是一樣的
Person person = (Person) obj; // 引用賦值
return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同

4.2 會創建“類對應的散列表”的情況

不會創建“類對應的散列表”的情況下，該類的“hashCode() 和 equals() ”是有關系的:

(1) 如果兩個對象相等，那么它們的hashCode()值一定相同。這里的“對象相等”是指通過equals()比較兩個對象時返回true。

(2) 如果兩個對象hashCode()相等，它們的equals()不一定相等。因為在散列表中，hashCode()相等，即兩個鍵值對的哈希值相等，然而哈希值相等，并不一定能得出鍵值對相等，此時就出現所謂的哈希沖突場景。

這里所說的“會創建類對應的散列表”是說：我們會在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中用到該類。

4.2.1 Set無法去重問題

自定義類作為HashSet的泛型，自定義類重寫equals()不重寫hashCode()，equals()的return true的范圍比hashCode() return 哈希值范圍大，導致HashSet中中出現重復元素，舉個例子，如下：

import java.util.HashSet;class Main3cumtomizeEquals {public static void main(String[] args) {Person p1 = new Person("eee", 100);Person p2 = new Person("eee", 100);Person p3 = new Person("aaa", 200);// 新建HashSet對象HashSet<Person> set = new HashSet<>();set.add(p1);set.add(p2);set.add(p3);// 比較p1 和 p2， 并打印它們的hashCode()System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());// 打印setSystem.out.printf("set:%s\n", set);}private static class Person {private String name;private int age;public Person(String name, int age) {super();this.name = name;this.age = age;}/*** 重寫equals方法,當其 name引用相同 && age引用相同 的時候就認為它相同，*/@Overridepublic boolean equals(Object obj) {if (obj == null) {return false;}// 如果是同一個對象返回true，反之返回falseif (this == obj) {return true; // 引用相同，返回為true}// 判斷是否類型相同if (this.getClass() != obj.getClass()) {return false; // getClass() 不相同，為false}Person person = (Person) obj; // 引用賦值return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同}} }

運行結果：

p1.equals(p2) : true; p1(2133927002) p2(1836019240) set:[package1.Main3cumtomizeEquals$Person@6d6f6e28, package1.Main3cumtomizeEquals$Person@7f31245a, package1.Main3cumtomizeEquals$Person@135fbaa4]

結果分析：

問題：上面的程序中，重寫了Person的equals()，但是，HashSet中仍然有重復元素：p1 和 p2。為什么會出現這種情況呢？

回答：因為雖然p1 和 p2的內容相等，但是它們的hashCode()不等，所以，HashSet在添加p1和p2的時候，認為它們不相等，從而導致存儲HashSet存儲重復元素。

4.2.2 哈希沖突問題

自定義類作為HashSet的泛型，自定義類重寫equals()并重寫hashCode()，hashCode() return 哈希值范圍比equals() return true范圍大，造成哈希沖突，舉個例子，如下：

import java.util.HashSet;class Main4cumtomizeEqualsAndhashcode {public static void main(String[] args) {// 新建Person對象Person p1 = new Person("eee", 100);Person p2 = new Person("eee", 100);Person p3 = new Person("aaa", 200);Person p4 = new Person("EEE", 100);// 新建HashSet對象HashSet<Person> set = new HashSet<>();set.add(p1);set.add(p2);set.add(p3);set.add(p4);// 比較p1 和 p2， 并打印它們的hashCode()System.out.printf("p1.equals(p2) : %s; p1(%d) p2(%d)\n", p1.equals(p2), p1.hashCode(), p2.hashCode());// 比較p1 和 p4， 并打印它們的hashCode()System.out.printf("p1.equals(p4) : %s; p1(%d) p4(%d)\n", p1.equals(p4), p1.hashCode(), p4.hashCode());// 打印setSystem.out.printf("set:%s\n", set);}private static class Person {private String name;private int age;public Person(String name, int age) {super();this.name = name;this.age = age;}/*** 重寫equals方法,當其 name引用相同 && age引用相同 的時候就認為它相同*/@Overridepublic boolean equals(Object obj) {if (obj == null) {return false;}// 如果是同一個對象返回true，反之返回falseif (this == obj) {return true; // 引用相同，返回為true}// 判斷是否類型相同if (this.getClass() != obj.getClass()) {return false; // getClass() 不相同，為false}Person person = (Person) obj; // 引用賦值return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同}/*** 重寫hashCode方法,邏輯為 name的哈希值^age*/@Overridepublic int hashCode() {// 68517 ^ 100 = 68545// 64545 ^ 200 =68545// 68517 ^ 100 =68545int nameHash = name.toUpperCase().hashCode();return nameHash ^ age; // ^ 異或運算，相同為0，不同為1}} }

運行結果：

p1.equals(p2) : true; p1(68545) p2(68545) // p1.equals(p4) : false; p1(68545) p4(68545) // hashcode相等，equals不相等，這樣還是不好 set:[package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@fce9]

結果分析：上面程序中，重寫hashCode()的同時重寫了equals()，equals()生效了，HashSet中沒有重復元素。

因為在HashSet比較p1和p2時，HashSet會發現，它們的hashCode()相等，通過equals()比較它們也返回true，所以，HashSet將p1和p2被視為相等，不會存儲多份。 同樣地，在比較p1和p4時，HashSet發現：雖然它們的hashCode()相等，但是通過equals()比較它們返回false，所以，HashSet將p1和p4被視為不相等，p1和p4各存儲一份。

4.2.3 equals()和hashCode()完全對應

上面代碼好的修改方法（讓equals和hashcode完全對應）：

/*** 重寫equals方法,當其 name引用相同 && age引用相同 的時候就認為它相同，*/ @Override public boolean equals(Object obj) {if (obj == null) {return false;}// 如果是同一個對象返回true，反之返回falseif (this == obj) {return true; // 引用相同，返回為true}// 判斷是否類型相同if (this.getClass() != obj.getClass()) {return false; // getClass() 不相同，為false}Person person = (Person) obj; // 引用賦值return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同 }/*** 重寫hashCode方法,邏輯為 name的哈希值^age*/ @Override public int hashCode() {int nameHash = name.hashCode();return nameHash ^ age; // ^ 異或運算，相同為0，不同為1 }

最后返回

p1.equals(p2) : true; p1(68545) p2(68545) // hashcode相等，equals相等 p1.equals(p4) : false; p1(68545) p4(68548) // hashcode不相等，equals不相等 set:[package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@10bc1, package1.Main4cumtomizeEqualsAndhashcode$Person@fce9]

4.2.4 進一步解釋為什么重寫equals()就要重寫hashCode()

/*** HashSet部分*/ public boolean add (E e){return map.put(e, PRESENT) == null; }??/*** map.put方法部分*/ public V put (K key, V value){return putVal(hash(key), key, value, false, true); }?/*** putVal方法部分*/ 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;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 {for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);if (binCount >= TREEIFY_THRESHOLD - 1) treeifyBin(tab, hash);break;}if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break;p = e;}}if (e != null) {V oldValue = e.value;if (!onlyIfAbsent || oldValue == null) e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;if (++size > threshold) resize();afterNodeInsertion(evict);return null; }

由上面HashSet源碼可知，HashSet使用的是HashMap的put方法，而hashMap的put方法，使用hashCode()用key作為參數計算出hash值，然后進行比較，如果相同，再通過equals()比較key值是否相同，如果相同，返回同一個對象。

所以，如果類使用再散列表的集合對象中，要判斷兩個對象是否相同，除了要覆蓋equals()之外，也要覆蓋hashCode()函數，否則，equals()無效。

所以，在HashSet中，一定要同時重寫hashCode()和equals()，HashSet底層是由于HashMap的數據結構（數組+鏈表/紅黑樹）的比較邏輯決定的。

五、重寫hashCode()的目標

理論上，一個好的hashCode的方法的目標：為不相等的對象（equals為false）產生不相等的散列碼，而相等的對象（equals為true）必須擁有相等的散列碼。

即equals和hashcode對應，向默認的那樣，既不會出現hashcode相等，equals不相等的哈希沖突，也不會出現equals相等，hashcode不相等造成HashSet存放equals為true的元素。

實際上，一般來說，hashcode相等，equals不相等的哈希沖突還能忍受，但是equals相等造成hashcode不相等，造成HashSet存放相同是一定不能忍受的，就是說，重寫equals放寬return true的同時一定要重寫hashcode放寬return 哈希碼。

以下驗證本文中心問題：

(1) 把某個非零的常數值，比如17，保存在一個int型的result中。

(2) 對于每個關鍵域f（equals方法中設計到的每個域），為該域計算int類型的散列碼，并

① 如果該域是boolean類型，則計算(f?1:0)；
② 如果該域是byte,char,short或者int類型,計算(int)f；
③ 如果是long類型，計算(int)(f^(f>>>32))；
④ 如果是float類型，計算Float.floatToIntBits(f)；
⑤ 如果是double類型，計算Double.doubleToLongBits(f),然后再計算long型的hash值；
⑥ 如果是對象引用，則遞歸的調用域的hashCode，如果是更復雜的比較，則需要為這個域計算一個范式，然后針對范式調用hashCode，如果為null，返回0；
⑦ 如果是一個數組，則把每一個元素當成一個單獨的域來處理。

(3) 執行result = 31 * result + name.hashcode()，并返回result。

(4) 編寫單元測試驗證有沒有實現所有相等的實例都有相等的散列碼。

給個簡單的例子（一個好的hashCode()的使用）：

@Overridepublic int hashCode() {int result = 17; result = 31 * result + name.hashCode(); return result; }

這里再說下2.b中為什么采用31*result + c,乘法使hash值依賴于域的順序，如果沒有乘法那么所有順序不同的字符串String對象都會有一樣的hash值，而31是一個奇素數，如果是偶數，并且乘法溢出的話，信息會丟失，31有個很好的特性是31*i ==(i<<5)-i,即2的5次方減1，虛擬機會優化乘法操作為移位操作的。

六、面試金手指

6.1 為什么重寫equals()一定要重寫hashCode()

6.1.1 不會創建“類對應的散列表”的情況

當我們不在HashSet, HashTable, HashMap等這些本質是散列表的數據結構中，用到這個類作為泛型，此時，這個類的hashCode() 和 equals()沒有任何關系；

equals()方法
(1) 作用： equals() 用來比較該類的兩個對象是否相等。
(2) 實現：equals未被重寫就直接進行引用比較，源碼如下：

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

若equals已被重寫，就按照自己的重寫equals邏輯來。

hashCode()：默認的hashcode()就是返回哈希值，但是此時返回的哈希值根本沒有任何作用，不用理會hashCode()。

當我們不在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中，用到這個類作為泛型，這種情況下，

(1) 不重寫equals，不重寫hashCode()
equals直接比較引用，hashCode()也是直接返回對象地址， 所以，equals()與hashCode()完全對應，即對于兩個引用：
① equals為true，hashCode()一定相等；
② equals為false，hashCode()一定不相等；
③ hashCode()相等，equals一定為true；
④ hashCode()不相等，equals一定為false。

(2) 重寫equals()為比較對象的屬性，不重寫hashCode()
① 如果equals()相等，表示兩個引用相等或兩個引用指向的對象各個屬性(基本類型+String)相等，hashcode()不一定相等（理由：因為一定要兩個引用相等，指向的對象地址才相等）。
② 如果hashCode()相等，表示兩個引用指向的對象哈希地址相等，則引用相等（因為哈對象哈希地址是任意分配的），equals()一定相等（未重寫比較引用相等，已重寫）。
③ 如果equals不相等，表示兩個引用一定不相等，hashcode()兩個引用所指向的對象地址一定不相等（因為哈希地址隨機分配）。
④ 如果hashcode不相等，兩個引用指向的對象地址不相等，equals()可以相等，可以不相等。

小結：不能說明equals()和hashCode()有關系，只是因為重寫equals()把return true;的條件放寬了，只要兩個引用指向的對象中屬性相等就好，不一定引用相等，但是hashCode()還是返回對象地址。

6.1.2 創建“類對應的散列表”的情況下

當我們在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中，用到這個類，就是這個類作為集合框架的泛型，此時，這個類的hashCode() 和 equals()緊密相關；因為這些散列表數據結構，對其泛型，要求兩個引用所指向的對象hashCode() 和 equals()均相同，才認為是同一個對象。

(1) 重寫equals()為比較對象的屬性，不重寫hashCode()

equals()相等，hashcode()可以不相等：HashSet中放入兩個相同就有相同屬性的Person對象，兩個Person對象屬性相同，所以equals比較兩個引用得到的結果相等，但是底層指向不同的對象地址，因此hashcode不相等，則HashSet在添加p1和p2的時候認為它們不相等，所以，HashSet中仍然有重復元素：p1 和 p2。

這說明默認的hashcode()不夠好，一個好的哈希算法不應該讓HashSet中有重復元素。因為要對應equals()的判斷為true要和hashCode()的判斷完全對應，默認的equals()和hashCode()就是比較引用和對象地址的，我們重寫的equals()和hashCode()，是比較引用所指向的對象的個數屬性的，總之，equals()和hashCode()要一一對應，所以重寫equals()就要重寫hashCode()。

(2) 重寫equals為比較對象的屬性，并且重寫hashCode()

重寫的equals()：兩個引用相等或者兩個引用所指向的對象的屬性相等，返回true，其余返回為false。
重寫的hashCode()： name的哈希值^age，異或運算，相同為0，不同為1。

重寫equals并且重寫hashCode()，三種情況如下：
① equals相等，hashcode()不相等：HashSet集合中的內容相同的元素(這就是重寫equals不重寫hashcode帶來的問題);
② equals相等，hashcode()相等：完全對應;
③ hashCode()相等，equals不相等：HashMap中的哈希沖突.

在完全對應的情況下，在HashSet看來：比較p1和p2，它們的hashCode()相等，通過equals()比較它們也返回true，所以p1和p2被視為相等；比較p1和p4，雖然它們的hashCode()相等；但是，通過equals()比較它們返回false，p1和p4被視為不相等。

小結：
(1) 不會創建“類對應的散列表”，hashcode除了打印引用所指向的對象地址看一看，沒有任何調用，重寫hashcode邏輯也沒有用，反正沒有調用，equals用來比較，可以自定義比較邏輯，hashcode和equals是兩個獨立方法，沒有任何關系，不存在重寫equals要重寫hashcode。
(2) 當我們在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中，用到這個類，就是這個類作為集合框架的泛型，此時，這個類的hashCode() 和 equals()緊密相關，因為這些散列表數據結構，對其泛型，要求兩個引用所指向的對象hashCode() 和 equals()均相同，才認為是同一個對象。

6.2 hashCode()底層實現，一個好的哈希算法

理論上，一個好的hashCode的方法的目標：為不相等的對象（equals為false）產生不相等的散列碼，同樣的，相等的對象（equals為true）必須擁有相等的散列碼，即equals和hashcode對應，向默認的那樣，既不會出現hashcode相等，equals不相等的哈希沖突，也不會出現equals相等，hashcode不相等造成HashSet存放equals為true的元素。

實踐上，一般來說，hashcode相等，equals不相等的哈希沖突還能忍受，但是equals相等造成hashcode不相等，造成HashSet存放相同是一定不能忍受的，就是說，重寫equals放寬return true;一定要重寫hashcode放寬return 哈希碼，驗證本文中心問題，一定要hashcode范圍和equals范圍一樣大，不能保證的化，就讓hashcode范圍比equals范圍大，允許哈希沖突不允許HashSet存放重復元素。

七、尾聲

為什么重寫equals()就要重寫hashCode()，完成了。

天天打碼，天天進步！！！

源代碼工程地址：https://download.csdn.net/download/qq_36963950/12674019

總結

以上是生活随笔為你收集整理的为什么重写equals()就要重写hashCode()的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。