一、hashCode()方法
hashCode() 方法：
(1) 作用：用于判斷兩個對象是否相等；
(2) 實現：通過獲取到的哈希碼來確定該對象在哈希表中的索引位置，哈希碼也稱散列碼，實際上就是返回一個int整數；
(3) Object類：hashCode() 定義在JDK的Object.java中，這就意味著Java中的任何類都包含有hashCode() 函數，并且通過調用hashCode()方法獲取對象的hash值。
舉個例子
|
1
2
3
4
5
6
|
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()方法比較兩個引用相等，引用復制就相等，淺復制和深復制都不相等。
舉個例子
|
1
2
3
4
5
6
|
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?
3.1 不會創建“類對應的散列表”的情況
不會創建“類對應的散列表”的情況下，
(1) hashCode()：hashCode()除了打印引用所指向的對象地址看一看，沒有任何調用，重寫hashCode()邏輯也沒有用，反正沒有調用；
(2) equals()：equals()用來比較，可以自定義比較邏輯；
(3) 關系：hashCode()和equals()是兩個獨立方法，沒有任何關系，所以不存在重寫equals()要重寫hashCode()。
這里所說的“不會創建類對應的散列表”是說：我們不會在HashSet, HashTable, HashMap等這些本質是散列表的數據結構中使用該類作為泛型。在這種情況下，該類的“hashCode() 和 equals() ”沒有半毛錢關系。
小結：當我們不在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中用到這個類，此時，equals() 用來比較該類的兩個對象是否相等，而hashCode() 則根本沒有任何作用，所以，不用理會hashCode()。
舉個例子
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
|
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方法 */ @Override public boolean equals(Object obj) { if (obj == null) { return false; } // 如果是同一個對象返回true，反之返回false if (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一定是一樣的
|
1
2
|
Person person = (Person) obj; // 引用賦值return name.equals(person.name) && age == person.age; // name引用相同 && age引用相同 |
3.2 會創建“類對應的散列表”的情況
不會創建“類對應的散列表”的情況下，該類的“hashCode() 和 equals() ”是有關系的:
(1) 如果兩個對象相等，那么它們的hashCode()值一定相同。這里的“對象相等”是指通過equals()比較兩個對象時返回true。
(2) 如果兩個對象hashCode()相等，它們的equals()不一定相等。因為在散列表中，hashCode()相等，即兩個鍵值對的哈希值相等，然而哈希值相等，并不一定能得出鍵值對相等，此時就出現所謂的哈希沖突場景。
這里所說的“會創建類對應的散列表”是說：我們會在HashSet, HashTable, HashMap等等這些本質是散列表的數據結構中用到該類。
3.2.1 Set無法去重問題
自定義類作為HashSet的泛型，自定義類重寫equals()不重寫hashCode()，equals()的return true的范圍比hashCode() return 哈希值范圍大，導致HashSet中中出現重復元素，舉個例子，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
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()); // 打印set System.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引用相同 的時候就認為它相同， */ @Override public boolean equals(Object obj) { if (obj == null) { return false; } // 如果是同一個對象返回true，反之返回false if (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存儲重復元素。
3.2.2 哈希沖突問題
自定義類作為HashSet的泛型，自定義類重寫equals()并重寫hashCode()，hashCode() return 哈希值范圍比equals() return true范圍大，造成哈希沖突，舉個例子，如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
|
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()); // 打印set System.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引用相同 的時候就認為它相同 */ @Override public boolean equals(Object obj) { if (obj == null) { return false; } // 如果是同一個對象返回true，反之返回false if (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() { // 68517 ^ 100 = 68545 // 64545 ^ 200 =68545 // 68517 ^ 100 =68545 int 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各存儲一份。
3.2.3 equals()和hashCode()完全對應
上面代碼好的修改方法（讓equals和hashcode完全對應）：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
/** * 重寫equals方法,當其 name引用相同 && age引用相同 的時候就認為它相同， */@Overridepublic boolean equals(Object obj) { if (obj == null) { return false; } // 如果是同一個對象返回true，反之返回false if (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() { 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]
3.2.4 進一步解釋為什么重寫equals()就要重寫hashCode()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
/** * 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，虛擬機會優化乘法操作為移位操作的。
五、面試金手指
5.1 為什么重寫equals()一定要重寫hashCode()
5.1.1 不會創建“類對應的散列表”的情況
當我們不在HashSet, HashTable, HashMap等這些本質是散列表的數據結構中，用到這個類作為泛型，此時，這個類的hashCode() 和 equals()沒有任何關系；
equals()方法
(1) 作用： equals() 用來比較該類的兩個對象是否相等。
(2) 實現：equals未被重寫就直接進行引用比較，源碼如下：
|
1
2
3
|
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()還是返回對象地址。
5.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()均相同，才認為是同一個對象。
5.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()，完成了。
源代碼工程地址：hashcode-equals.rar
到此這篇關于淺談為什么重寫equals()就要重寫hashCode()的文章就介紹到這了,更多相關重寫equals()就要重寫hashCode()內容請搜索服務器之家以前的文章或繼續瀏覽下面的相關文章希望大家以后多多支持服務器之家！
原文鏈接：https://blog.csdn.net/qq_36963950/article/details/121003221
