Java中的equals()和hashCode() – 超詳細篇
前言
大家好啊，我是湯圓，今天給大家帶來的是《Java中的equals()和hashCode() – 詳細篇》，希望對大家有幫助，謝謝
文章純屬原創，個人總結難免有差錯，如果有，麻煩在評論區回復或後台私信，謝啦
簡介
說到equals和hashCode，首先要說下Object
我們都知道，這個Object是Java所有類的超類，其他類都是從Object直接或間接繼承而來的
而Object中自帶的equals和hashCode方法就是今天我們要談論的話題
目錄
- 什麼是equals()方法
- 什麼是hashCode()方法
- equals和hashCode有啥關係
- 等等
正文
PS：正文可能比較長，有點像是一層層在剝洋蔥，所以會顯得有點啰嗦，需要看結論的可以直接跳到文末看總結
什麼是equals方法
equals方法用來比較兩個對象的屬性是否相等，也可以說是比較兩個引用對象是否為同一個對象（因為Object中的equals就是這個意
思，如果你沒有覆寫equals方法，那麼就可以這麼說）
因為在Object中沒有屬性，所以就只比較了兩個引用指向的對象是否相等
只要對象不相等，那麼就返回false（其實這樣對子類來說是很不友好的，太絕對了，請往下看）
程式碼如下所示：
public class Object {
public boolean equals(Object obj) {
// 可以看到，官方括弧的寫法很規範（向老人家學習）
return (this == obj);
}
}
但是我們平時在定義類時，都或多或少會包含幾個屬性
比如下面的例子
public class EqualsDemo {
private int m;
// 省略 getter,setter,constructor(m)
public static void main(String[] args) {
EqualsDemo demo1 = new EqualsDemo(1);
EqualsDemo demo2 = new EqualsDemo(1);
// 這裡期望返回true，實際卻是false
System.out.println(demo1.equals(demo2));
}
// 這裡延續Object的寫法，只單純地比較兩個引用指向的對象是否相等
@Override
public boolean equals(Object o) {
return this == o;
}
}
其中定義了一個基本類型的屬性 int m；
然後兩個實例 demo1 和 demo2 都擁有相同的屬性 m = 1;
但是equals方法卻返回false
原因就是，equals方法沒有正確地編寫
equals怎麼才算正確編寫呢？
我們應該把屬性也進行比對，而不是單純地比較對象的引用
（這就好比我們選一半，不能只看外在，而是要外在內在一起看，那樣就。。。就都單著吧）
修正後的程式碼如下所示：
public class EqualsDemo {
private int m;
// 省略 getter,setter,constructor(m)
public static void main(String[] args) {
EqualsDemo demo1 = new EqualsDemo(1);
EqualsDemo demo2 = new EqualsDemo(1);
// 這時就會返回true
System.out.println(demo1.equals(demo2));
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
// 加了下面這兩行，對屬性進了比對
EqualsDemo that = (EqualsDemo) o;
return m == that.m;
}
}
上面看起來好像沒什麼問題了，但是實際運行卻很容易出現空指針異常或者類型轉換異常
因為equals方法中，我們在強轉之前沒有對參數 o 進行檢查
檢查什麼呢？
檢查兩個地方：
-
首先要確保o不能為空null
-
其次確保o是EqualsDemo類或者子類（父類行不行？不行，父類沒有子類特有的屬性，強轉還是會報錯）
程式碼如下：
public class EqualsDemo {
private int m;
// 省略 getter,setter,constructor(m)
public static void main(String[] args) {
EqualsDemo demo1 = new EqualsDemo(1);
EqualsDemo demo2 = new EqualsDemo(1);
System.out.println(demo1.equals(demo2));
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
// 加了這一行判斷
if (!(o instanceof EqualsDemo)) return false;
EqualsDemo that = (EqualsDemo) o;
return m == that.m;
}
}
上面用到了instanceof來判斷（別，我知道你要說啥，朋友咱先往下看）
instanceof的用法是 A instanceof B，用來判斷A是否為B類或者B的子類
這樣就可以防止空指針和轉換異常的出現
所以equals判斷的內容總結下來就是三步：
-
判斷兩個引用指向的對象是否相等
-
判斷傳來的參數是否為當前類或者當前類的子類
-
比較各個屬性值是否相等
如果屬性是對象的引用，那第三步該怎麼比呢？
那就有點像套娃了（什麼？沒聽過套娃？強烈推薦你去看陳翔六點半，裡面有很多套娃的案例【您的賬戶已到賬0.5毛】）
比如下面的程式碼
public class EqualsDemo {
private int m;
private String str;
public static void main(String[] args) {
EqualsDemo demo1 = new EqualsDemo(1, "JavaLover1");
EqualsDemo demo2 = new EqualsDemo(1, "JavaLover1");
System.out.println(demo1.equals(demo2));
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof EqualsDemo)) return false;
EqualsDemo demo = (EqualsDemo) o;
// 改了這行
return m == demo.m && str.equals(demo.str);
}
}
可以看到，多了一個String對象引用作為屬性
那我們在比較的時候，根據套娃的原則，再次利用String對象的equals方法進行比較即可
其他的部分都一樣
好了，現在equals方法寫完了，我上個廁所先
真的寫完了嗎？我不信（腦補ing。。。）
因為還是有潛在的空指針異常
設想一下，上面str真的會存在嗎？如果str為null怎麼辦？
所以我們還要對str進行空指針判斷，不過不需要我們來做，而是通過Objects這個工具類（Java7誕生的一個工具類），它內置的equals
方法可以幫你在比較兩個對象的同時加上null判斷
Objects.equals方法如下：
public final class Objects {
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
}
改了以後的equals()最終程式碼如下：
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof EqualsDemo)) return false;
EqualsDemo demo = (EqualsDemo) o;
return m == demo.m && Objects.equals(str,demo.str);
}
好了，萬事俱備了，只欠東風
東風？什麼東風？
東風就是你的父親啊
如果是在子類中定義equals，那麼還要考慮到父類（如果直接繼承自Object則不考慮）
改了之後的程式碼如下：
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof EqualsDemo)) return false;
// 加了這一行
if(!super.equals(o)) return false;
EqualsDemo demo = (EqualsDemo) o;
return m == demo.m && Objects.equals(str,demo.str);
}
你可能想知道，為啥放到第三行？
那是因為前兩行屬於最外側的判斷
你可以這樣想，如果傳來的對象o是父類的對象，那麼父類super的判斷放在這個位置就很合適了
（因為此時o instanceof EqualsDemo肯定返回false,這樣就省去了super.equals()的判斷)
好了，我累了，可以結束了嗎？
等一下，地球還沒有毀滅，事情也還沒有結束。
上面的instanceof有個很大的缺陷，就是違反了equals的對稱性
下面我們順藤摸瓜，來說下equals方法規範的5個特性：
- 自反性：就是自己反過來跟自己比，要返回true；比如x.equals(x) == true
- 對稱性：就是x.equals(y) == true時，也要y.equals(y) == true
- 傳遞性：就是x.equals(y) == true,同時y.equals(z) == true，那麼x.equals(z) == true
- 一致性：就是傳說中的冪等性，即x.equals(y)調用多次，都應該返回一樣的結果
- 非空和空比較則返回false的特性：就是x.equals(y)中，如果x非空，而y空，則返回false
好了，回到instanceof，上面提到它沒有滿足對稱性
是因為用了instanceof來做比較的話，Son.equals(Father)永遠不會為真，而Father.equals(Son)卻有可能為真，這就不對稱了
所以乾脆就讓Father.equals(Son)也永遠不為真
那要怎麼做呢？
答案就是instanceof的弟弟：getClass
instanceof用來判斷是否為當前類或者子類
而getClass只用來判斷是否為當前類
改了之後，程式碼如下
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if(!super.equals(o)) return false;
EqualsDemo demo = (EqualsDemo) o;
return m == demo.m && Objects.equals(str,demo.str);
}
好了，看朋友們也累了，今天的equals方法就先到這裡了
下面總結下equals方法的核心內容，總共就是五步（這次真的是結束了）：
- 判斷兩個引用指向的對象是否相等
- 判斷傳來的參數是否為空
- 判斷傳來的參數是否屬於當前類
- 如果有繼承父類，則也需要調用父類的super.equals()方法（Object除外）
- 最後比較各個屬性值是否相等（如果屬性為對象引用，則需要通過Objects.equals(a,b)方法來比較引用對象的屬性值）
什麼是hashCode()方法
hashCode也叫散列碼（哈希碼），它用來計算對象中所有屬性的散列值
關於散列這裡就不展開了，我們在這裡只需要知道兩點：
- 散列值為整數，可以為負值
- 散列值可以用來確定元素在散列表中的位置（有可能兩個元素擁有相同的散列值，這個就是散列衝突）
在Object中，hashCode()是一個本地方法，因為Object沒有屬性，所以默認返回的是對象的記憶體地址
程式碼如下所示：
public class Test2 {
public static void main(String[] args) {
Object t = new Object();
int a = t.hashCode();
System.out.println(Integer.toHexString(a)); // 輸出 4554617c
}
}
其中4554617c就是對象a的記憶體地址,這裡轉成16進位顯示（是因為通常地址都是用16進位顯示的，比如我們電腦的Mac地址）
下面總結下hashCode的幾個特性：
- 一致性：無論hashCode調用多少次，都應該返回一樣的結果(這一點跟equals很像)
- 跟隨性（自己編的一個性）：如果兩個對象的equals返回為真，那麼hashCode也應該相等
- 反過來，如果兩個對象的equals返回為假，那麼hashCode有可能相等，但是如果散列的足夠好，那麼通常來說hashCode()也不應該相等
- 覆寫equals方法時，一定要覆寫hashCode方法
equals和hashCode有什麼聯繫呢？
hashCode和equals可以說相輔相成的，他倆共同協作用來判斷兩個對象是否相等
如果分開來看的話，他倆是沒什麼聯繫的，但是由於某些原因導致被聯繫上了（比如HashMap這個小月老）
下面來細說一下
我們知道 HashMap集合中的key是不能重複的，那它是怎麼判斷重複的呢？
就是通過equals和hashCode來判斷的
下面是部分源碼
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
可以看到，map先進行hash判斷，然後進行equals判斷
也就是說，hash是前提，如果hash都不相等，那equals就不用比較了（先計算hash的一個原因是計算hash比equals快得多）
所以我們在自定義對象時，如果覆寫了equals，那麼一定要記得覆寫hashCode,(當然，假設這裡的自定義對象是用來作為map中的key鍵的)
覆寫程式碼如下：
@Override
public boolean equals(Object o) {
if (this == o) return true;
if(getClass() != o.getClass()) return false;
if(!super.equals(o)) return false;
EqualsDemo demo = (EqualsDemo) o;
return m == demo.m && Objects.equals(str,demo.str);
}
@Override
public int hashCode() {
return Objects.hash(m, str);
}
其中Objects.hash有點類似於上面的Objects.equals()方法，很實用
如果只覆寫了equals，沒有覆寫hashCode,會咋樣呢？
結果就是：
當你創建兩個對象（屬性一致，但是記憶體地址不一致），作為key放到map中時就會被當成兩個key來存放
同理可得，獲取數據value的時候，也是不一致的
下面是只覆寫equals沒覆寫hashCode的程式碼：可以看到，兩次取到的值是不一樣的
public class HashCodeDemo{
public static void main(String[] args) {
// 兩個對象的屬性都為n = 1
HashCodeDemo demo1 = new HashCodeDemo(1);
HashCodeDemo demo2 = new HashCodeDemo(1);
Map<HashCodeDemo, Integer> map = new HashMap<>();
map.put(demo1, 1);
map.put(demo2, 2);
System.out.println(map.get(demo1)); // 輸出1
System.out.println(map.get(demo2)); // 輸出2
}
private int n;
public HashCodeDemo(int n) {
this.n = n;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
HashCodeDemo that = (HashCodeDemo) o;
return n == that.n;
}
public int getN() {
return n;
}
public void setN(int n) {
this.n = n;
}
}
同時覆寫equals和hashCode的程式碼：可以看到，兩次取到的值都是一樣的
public class HashCodeDemo{
public static void main(String[] args) {
HashCodeDemo demo1 = new HashCodeDemo(1);
HashCodeDemo demo2 = new HashCodeDemo(1);
Map<HashCodeDemo, Integer> map = new HashMap<>();
map.put(demo1, 1);
// 第二次會覆蓋第一次的值，因為key相等（equals和hashCode都相等）
map.put(demo2, 2);
System.out.println(map.get(demo1)); // 輸出2
System.out.println(map.get(demo2)); // 輸出2
}
private int n;
public HashCodeDemo(int n) {
this.n = n;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
HashCodeDemo that = (HashCodeDemo) o;
return n == that.n;
}
@Override
public int hashCode() {
return Objects.hash(m, str);
}
public int getN() {
return n;
}
public void setN(int n) {
this.n = n;
}
}
HashSet集合也是同理，因為它內部的就是依賴HashMap實現的（這個前面有簡單介紹過，感興趣的可以回顧一下）
總結
- equals方法的特性：
- 自反性：就是自己反過來跟自己比，要返回true；比如x.equals(x) == true
- 對稱性：就是x.equals(y) == true時，也要y.equals(y) == true
- 傳遞性：就是x.equals(y) == true,同時y.equals(z) == true，那麼x.equals(z) == true
- 一致性：就是傳說中的冪等性，即x.equals(y)調用多次，都應該返回一樣的結果
- 非空和空比較則返回false的特性：就是x.equals(y)中，如果x非空，而y空，則返回false
- hashCode的特性以及和equals的聯繫
- 一致性：無論hashCode調用多少次，都應該返回一樣的結果(這一點跟equals很像)
- 跟隨性（自己編的一個性）：如果兩個對象的equals返回為真，那麼hashCode也應該相等
- 反過來，如果兩個對象的equals返回為假，那麼hashCode有可能相等，但是如果散列的足夠好，那麼通常來說hashCode()也不應該相等
- 覆寫equals方法時，一定要覆寫hashCode方法
後記
最後，感謝大家的觀看，謝謝
