面試官：重寫 equals 時爲什麼一定要重寫 hashCode？

重要說明：本篇爲博主《面試題精選-基礎篇》系列中的一篇，關注我，查看更多面試題。Gitee 面試題系列開源地址：https://gitee.com/mydb/interview

本題目難度：低

常見程度：高

equals 方法和 hashCode 方法是 Object 類中的兩個基礎方法，它們共同協作來判斷兩個對象是否相等。爲什麼要這樣設計嘞？原因就出在“性能” 2 字上。
​

使用過 HashMap 我們就知道，通過 hash 計算之後，我們就可以直接定位出某個值存儲的位置了，那麼試想一下，如果你現在要查詢某個值是否在集合中？如果不通過 hash 方式直接定位元素（的存儲位置），那麼就只能按照集合的前後順序，一個一個的詢問比對了，而這種依次比對的效率明顯低於 hash 定位的方式。這就是 hash 以及 hashCode 存在的價值。


當我們對比兩個對象是否相等時，我們就可以先使用 hashCode 進行比較，如果比較的結果是 true，那麼就可以使用 equals 再次確認兩個對象是否相等，如果比較的結果是 true，那麼這兩個對象就是相等的，否則其他情況就認爲兩個對象不相等。這樣就大大的提升了對象比較的效率，這也是爲什麼 Java 設計使用 hashCode 和 equals 協同的方式，來確認兩個對象是否相等的原因。
​

那爲什麼不直接使用 hashCode 就確定兩個對象是否相等呢？
​

這是因爲不同對象的 hashCode 可能相同；但 hashCode 不同的對象一定不相等，所以使用 hashCode 可以起到快速初次判斷對象是否相等的作用。
​

但即使知道了以上基礎知識，依然解決不了本篇的問題，也就是：重寫 equals 時爲什麼一定要重寫 hashCode？要想了解這個問題的根本原因，我們還得先從這兩個方法開始說起。

1.equals 方法

Object 類中的 equals 方法用於檢測一個對象是否等於另外一個對象。在 Object 類中，這個方法將判斷兩個對象是否具有相同的引用。如果兩個對象具有相同的引用，它們一定是相等的。
​

equals 方法的實現源碼如下：

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

通過上述源碼和 equals 的定義我們可以看出，在大多數情況來說，equals 的判斷是沒有什麼意義的！例如，使用 Object 中的 equals 比較兩個自定義的對象是否相等，這就完全沒有意義（因爲無論對象是否相等，結果都是 false）。

通過以下示例，就可以說明這個問題：

public class EqualsMyClassExample {
    public static void main(String[] args) {
        Person u1 = new Person();
        u1.setName("Java");
        u1.setAge(18);
		
        Person u2 = new Person();
        u1.setName("Java");
        u1.setAge(18);
        
        // 打印 equals 結果
        System.out.println("equals 結果：" + u1.equals(u2));
    }
}

class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

以上程序的執行結果，如下圖所示：

因此通常情況下，我們要判斷兩個對象是否相等，一定要重寫 equals 方法，這就是爲什麼要重寫 equals 方法的原因。

2.hashCode 方法

hashCode 翻譯爲中文是散列碼，它是由對象推導出的一個整型值，並且這個值爲任意整數，包括正數或負數。
​

需要注意的是：散列碼是沒有規律的。如果 x 和 y 是兩個不同的對象，x.hashCode() 與 y.hashCode() 基本上不會相同；但如果 a 和 b 相等，則 a.hashCode() 一定等於 b.hashCode()。
​

hashCode 在 Object 中的源碼如下：

public native int hashCode();

從上述源碼可以看到，Object 中的 hashCode 調用了一個（native）本地方法，返回了一個 int 類型的整數，當然，這個整數可能是正數也可能是負數。

hashCode 使用

相等的值 hashCode 一定相同的示例：

public class HashCodeExample {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "Hello";
        String s3 = "Java";
        System.out.println("s1 hashCode:" + s1.hashCode());
        System.out.println("s2 hashCode:" + s2.hashCode());
        System.out.println("s3 hashCode:" + s3.hashCode());
    }
}

以上程序的執行結果，如下圖所示：

---

不同的值 hashCode 也有可能相同的示例：

public class HashCodeExample {
    public static void main(String[] args) {
        String s1 = "Aa";
        String s2 = "BB";
        System.out.println("s1 hashCode:" + s1.hashCode());
        System.out.println("s2 hashCode:" + s2.hashCode());
    }
}

以上程序的執行結果，如下圖所示：

3.爲什麼要一起重寫？

接下來回到本文的主題，重寫 equals 爲什麼一定要重寫 hashCode？
​

爲了解釋這個問題，我們需要從下面的這個例子入手。

3.1 Set 正常使用

Set 集合是用來保存不同對象的，相同的對象就會被 Set 合併，最終留下一份獨一無二的數據。
​

它的正常用法如下：

import java.util.HashSet;
import java.util.Set;

public class HashCodeExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet();
        set.add("Java");
        set.add("Java");
        set.add("MySQL");
        set.add("MySQL");
        set.add("Redis");
        System.out.println("Set 集合長度:" + set.size());
        System.out.println();
        // 打印 Set 中的所有元素
        set.forEach(d -> System.out.println(d));
    }
}

以上程序的執行結果，如下圖所示：

從上述結果可以看出，重複的數據已經被 Set 集合“合併”了，這也是 Set 集合最大的特點：去重。

3.2 Set 集合的“異常”

然而，如果我們在 Set 集合中存儲的是，只重寫了 equals 方法的自定義對象時，有趣的事情就發生了，如下代碼所示：

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class EqualsExample {
    public static void main(String[] args) {
        // 對象 1
        Persion p1 = new Persion();
        p1.setName("Java");
        p1.setAge(18);
		// 對象 2
        Persion p2 = new Persion();
        p2.setName("Java");
        p2.setAge(18);
		// 創建 Set 集合
        Set<Persion> set = new HashSet<Persion>();
        set.add(p1);
        set.add(p2);
		// 打印 Set 中的所有數據
        set.forEach(p -> {
            System.out.println(p);
        });
    }
}


class Persion {
    private String name;
    private int age;

    // 只重寫了 equals 方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true; // 引用相等返回 true
        // 如果等於 null，或者對象類型不同返回 false
        if (o == null || getClass() != o.getClass()) return false;
        // 強轉爲自定義 Persion 類型
        Persion persion = (Persion) o;
        // 如果 age 和 name 都相等，就返回 true
        return age == persion.age &&
                Objects.equals(name, persion.name);
    }
	
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
     @Override
    public String toString() {
        return "Persion{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

以上程序的執行結果，如下圖所示：

從上述代碼和上述圖片可以看出，即使兩個對象是相等的，Set 集合竟然沒有將二者進行去重與合併。這就是重寫了 equals 方法，但沒有重寫 hashCode 方法的問題所在。

3.3 解決“異常”

爲了解決上面的問題，我們嘗試在重寫 equals 方法時，把 hashCode 方法也一起重寫了，實現代碼如下：

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class EqualsToListExample {
    public static void main(String[] args) {
        // 對象 1
        Persion p1 = new Persion();
        p1.setName("Java");
        p1.setAge(18);
		// 對象 2
        Persion p2 = new Persion();
        p2.setName("Java");
        p2.setAge(18);
		// 創建 Set 對象
        Set<Persion> set = new HashSet<Persion>();
        set.add(p1);
        set.add(p2);
		// 打印 Set 中的所有數據
        set.forEach(p -> {
            System.out.println(p);
        });
    }
}


class Persion {
    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true; // 引用相等返回 true
        // 如果等於 null，或者對象類型不同返回 false
        if (o == null || getClass() != o.getClass()) return false;
        // 強轉爲自定義 Persion 類型
        Persion persion = (Persion) o;
        // 如果 age 和 name 都相等，就返回 true
        return age == persion.age &&
                Objects.equals(name, persion.name);
    }

    @Override
    public int hashCode() {
        // 對比 name 和 age 是否相等
        return Objects.hash(name, age);
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    @Override
    public String toString() {
        return "Persion{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

以上程序的執行結果，如下圖所示：

通過上述結果可以看出，當我們一起重寫了兩個方法之後，奇蹟的事情又發生了，Set 集合又恢復正常了，這是爲什麼呢？

3.4 原因分析

出現以上問題的原因是，如果只重寫了 equals 方法，那麼默認情況下，Set 進行去重操作時，會先判斷兩個對象的 hashCode 是否相同，此時因爲沒有重寫 hashCode 方法，所以會直接執行 Object 中的 hashCode 方法，而 Object 中的 hashCode 方法對比的是兩個不同引用地址的對象，所以結果是 false，那麼 equals 方法就不用執行了，直接返回的結果就是 false：兩個對象不是相等的，於是就在 Set 集合中插入了兩個相同的對象。
​

但是，如果在重寫 equals 方法時，也重寫了 hashCode 方法，那麼在執行判斷時會去執行重寫的 hashCode 方法，此時對比的是兩個對象的所有屬性的 hashCode 是否相同，於是調用 hashCode 返回的結果就是 true，再去調用 equals 方法，發現兩個對象確實是相等的，於是就返回 true 了，因此 Set 集合就不會存儲兩個一模一樣的數據了，於是整個程序的執行就正常了。

總結

hashCode 和 equals 兩個方法是用來協同判斷兩個對象是否相等的，採用這種方式的原因是可以提高程序插入和查詢的速度，如果在重寫 equals 時，不重寫 hashCode，就會導致在某些場景下，例如將兩個相等的自定義對象存儲在 Set 集合時，就會出現程序執行的異常，爲了保證程序的正常執行，所以我們就需要在重寫 equals 時，也一併重寫 hashCode 方法纔行。

關注公衆號：Java面試真題解析，查看更多 Java 面試題。