文章目錄
- 一、前言
- 二、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方法
*/
@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一定是一樣的
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());
// 列印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存盤重復元素，
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());
// 列印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各存盤一份，
4.2.3 equals()和hashCode()完全對應
上面代碼好的修改方法（讓equals和hashcode完全對應）：
/**
* 重寫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() {
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
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/340736.html
標籤：java