Java中的equals()和hashCode() - 超詳細篇-有解無憂

前言

大家好啊，我是湯圓，今天給大家帶來的是《Java中的equals()和hashCode() - 詳細篇》，希望對大家有幫助，謝謝

文章純屬原創，個人總結難免有差錯，如果有，麻煩在評論區回復或后臺私信，謝啦

簡介

說到equals和hashCode，首先要說下Object

我們都知道，這個Object是Java所有類的超類，其他類都是從Object直接或間接繼承而來的

而Object中自帶的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方法

后記

最后，感謝大家的觀看，謝謝

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/274971.html

標籤：Java

上一篇：支持正則運算式更名的命令列工具

下一篇：Kafka集群搭建

Java中的equals()和hashCode() - 超詳細篇

前言

簡介

目錄

正文

什么是equals方法

什么是hashCode()方法

equals和hashCode有什么聯系呢？

總結

后記