Java之hashCode()和equals()方法

時間 2019-11-07

標籤 java hashcode equals 方法欄目 Java 简体版

原文原文鏈接

程序世界和現實世界實際上是同樣的，相等和相同是不一樣的概念，就此簡要說明一下其中的含義：java

1 equals() 的做用是什麼？數組

2 equals() 與 == 的區別是什麼？數據結構

3 hashCode() 的做用是什麼？函數

4 hashCode() 和 equals() 之間有什麼聯繫？this

第1部分 equals() 的做用spa

equals() 的做用是 用來判斷兩個對象是否相等。有5個很重要的特性：code

1. 對稱性：若是x.equals(y)返回是"true"，那麼y.equals(x)也應該返回是"true"。
2. 反射性：x.equals(x)必須返回是"true"。
3. 類推性：若是x.equals(y)返回是"true"，並且y.equals(z)返回是"true"，那麼z.equals(x)也應該返回是"true"。
4. 一致性：若是x.equals(y)返回是"true"，只要x和y內容一直不變，無論你重複x.equals(y)多少次，返回都是"true"。
5. 非空性，x.equals(null)，永遠返回是"false"；x.equals(和x不一樣類型的對象)永遠返回是"false"。

equals() 定義在JDK的Object.java中。經過判斷兩個對象的地址是否相等(即，是不是同一個對象)來區分它們是否相等。源碼以下：對象

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

既然Object.java中定義了equals()方法，這就意味着全部的Java類都實現了equals()方法，全部的類均可以經過equals()去比較兩個對象是否相等。可是，咱們已經說過，使用默認的「equals()」方法，等價於「==」方法。所以，咱們一般會重寫equals()方法：若兩個對象的內容相等，則equals()方法返回true；不然，返回fasle。索引

下面根據「類是否覆蓋equals()方法」，將它分爲2類。
(01) 若某個類沒有覆蓋equals()方法，當它的經過equals()比較兩個對象時，其實是比較兩個對象是否是同一個對象。這時，等價於經過「==」去比較這兩個對象。
(02) 咱們能夠覆蓋類的equals()方法，來讓equals()經過其它方式比較兩個對象是否相等。一般的作法是：若兩個對象的內容相等，則equals()方法返回true；不然，返回fasle。get

下面，舉例對上面的2種狀況進行說明。

1. 「沒有覆蓋equals()方法」的狀況，簡要代碼：

    public static void main(String[] args) {        
        Person p1 = new Person("dongguangming", 25);
        Person p2 = new Person("dongguangming", 25);
        System.out.println(p1.equals(p2));
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是："+name + ",年齡是：" +age;
        }
    }

輸出結果：false

結果分析：咱們經過 p1.equals(p2) 來「比較p1和p2是否相等時」。實際上，調用的Object.java的equals()方法，即調用的 (p1==p2) 。它是比較「p1和p2是不是同一個對象」。
而由 p1 和 p2 的定義可知，它們雖然內容相同；但它們是兩個不一樣的對象！所以，返回結果是false。

2. "覆蓋equals()方法"的狀況，簡要代碼：

    public static void main(String[] args) {
     Person p1 = new Person("dongguangming", 25);
     Person p2 = new Person("dongguangming", 25);
     System.out.println(p1.equals(p2));
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是："+name + ",年齡是：" +age;
        }
        
        //複寫Object類中默認的equals（）
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //若是是同一個對象，返回ture
        if(this ==obj){
        return true;
        }
        
        //判斷是否爲同一類型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

輸出結果：true

分析結論：因爲重寫了Person的equals()方法：當兩個Person對象的 name 和 age 都相等，則返回true。所以，運行結果返回true。

第2部分 equals() 與 == 的區別是什麼？

== : 它的做用是判斷兩個對象的地址是否是相等。即，判斷兩個對象是不試同一個對象。

equals() : 它的做用也是判斷兩個對象是否相等。但它通常有兩種使用狀況：
狀況1，類沒有覆蓋equals()方法。則經過equals()比較該類的兩個對象時，等價於經過「==」比較這兩個對象。
狀況2，類覆蓋了equals()方法。通常，咱們都覆蓋equals()方法來兩個對象的內容相等；若它們的內容相等，則返回true(即，認爲這兩個對象相等)。

簡要代碼以下：

   public static void main(String[] args) {
     Person p1 = new Person("dongguangming", 25);
     Person p2 = new Person("dongguangming", 25);
     System.out.println(p1.equals(p2));
     System.out.println(p1.==p2);
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是："+name + ",年齡是：" +age;
        }
        
        //複寫Object類中默認的equals（）
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //若是是同一個對象，返回ture
        if(this ==obj){
        return true;
        }
        
        //判斷是否爲同一類型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

輸出結果：true，false

結論分析：

a. p1.equals(p2)
這是判斷p1和p2的內容是否相等。由於Person覆蓋equals()方法，而這個equals()是用來判斷p1和p2的內容是否相等，偏偏p1和p2的內容又相等；所以，返回true。

b. p1==p2
這是判斷p1和p2是不是同一個對象。因爲它們是各自新建的兩個Person對象；所以，返回false。

第3部分 hashCode() 的做用

hashCode() 的做用是獲取哈希碼，也稱爲散列碼；它其實是返回一個int整數。這個哈希碼的做用是肯定該對象在哈希表中的索引位置。

hashCode() 定義在JDK的Object.java中，這就意味着Java中的任何類都包含有hashCode() 函數。
雖然，每一個Java類都包含hashCode() 函數。可是，僅僅當建立並某個「類的散列表」(關於「散列表」見下面說明)時，該類的hashCode() 纔有用(做用是：肯定該類的每個對象在散列表中的位置；其它狀況下(例如，建立類的單個對象，或者建立類的對象數組等等)，類的hashCode() 沒有做用。
上面的散列表，指的是：Java集合中本質是散列表的類，如HashMap，Hashtable，HashSet。

也就是說：hashCode() 在散列表中才有用，在其它狀況下沒用。在散列表中hashCode() 的做用是獲取對象的散列碼，進而肯定該對象在散列表中的位置。

下面，咱們以HashSet爲例，來深刻說明hashCode()的做用。

假設，HashSet中已經有1000個元素。當插入第1001個元素時，須要怎麼處理？由於HashSet是Set集合，它容許有重複元素。
「將第1001個元素逐個的和前面1000個元素進行比較」？顯然，這個效率是相等低下的。散列表很好的解決了這個問題，它根據元素的散列碼計算出元素在散列表中的位置，而後將元素插入該位置便可。對於相同的元素，天然是隻保存了一個。
由此可知，若兩個元素相等，它們的散列碼必定相等；但反過來確不必定。在散列表中，
一、若是兩個對象相等，那麼它們的hashCode()值必定要相同；
二、若是兩個對象hashCode()相等，它們並不必定相等。
注意：這是在散列表中的狀況。在非散列表中必定如此！

第4部分 hashCode() 和 equals() 的關係

咱們以「類的用途」來將「hashCode() 和 equals()的關係」分2種狀況來講明。

1. 第一種不會建立「類對應的散列表」

這裏所說的「不會建立類對應的散列表」是說：咱們不會在HashSet, Hashtable, HashMap等等這些本質是散列表的數據結構中，用到該類。例如，不會建立該類的HashSet集合。

在這種狀況下，該類的「hashCode() 和 equals() 」沒有關係！
這種狀況下，equals() 用來比較該類的兩個對象是否相等。而hashCode() 則根本沒有任何做用，因此，不用理會hashCode()。

下面，咱們經過示例查看類的兩個對象相等 以及不等時hashCode()的取值。

public static void main(String[] args) {
     Person dongguangming = new Person("dongguangming", 25);
     Person dgm= new Person("dongguangming", 25);
     Person gaoyafei = new Person("gaoyafei", 25);
     System.out.println(dongguangming.equals(dgm)+","+dongguangming.hashCode()+","+dgm.hashCode());
    System.out.println(dongguangming.equals(gaoyafei)+","+dongguangming.hashCode()+","+gaoyafei.hashCode());
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是："+name + ",年齡是：" +age;
        }
        
        //複寫Object類中默認的equals（）
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //若是是同一個對象，返回ture
        if(this ==obj){
        return true;
        }
        
        //判斷是否爲同一類型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

輸出結果：

true,6413875,21174459

false,6413875,827574

由此得出結論：對象相等的狀況下，hashCode不必定相等。

2. 第二種會建立「類對應的散列表」

這裏所說的「會建立類對應的散列表」是說：咱們會在HashSet, Hashtable, HashMap等等這些本質是散列表的數據結構中，用到該類。例如，會建立該類的HashSet集合。

在這種狀況下，該類的「hashCode() 和 equals() 」是有關係的：
1)、若是兩個對象相等，那麼它們的hashCode()值必定相同。
這裏的相等是指，經過equals()比較兩個對象時返回true。
2)、若是兩個對象hashCode()相等，它們並不必定相等。
由於在散列表中，hashCode()相等，即兩個鍵值對的哈希值相等。然而哈希值相等，並不必定能得出鍵值對相等。補充說一句：「兩個不一樣的鍵值對，哈希值相等」，這就是哈希衝突。

此外，在這種狀況下。若要判斷兩個對象是否相等，除了要覆蓋equals()以外，也要覆蓋hashCode()函數。不然，equals()無效。
例如，建立Person類的HashSet集合，必須同時覆蓋Person類的equals() 和 hashCode()方法。
若是單單只是覆蓋equals()方法。咱們會發現，equals()方法沒有達到咱們想要的效果。

簡要代碼以下：

public static void main(String[] args) {
     Person dongguangming = new Person("dongguangming", 25);
     Person dgm= new Person("dongguangming", 25);
     Person gaoyafei = new Person("gaoyafei", 25);
     System.out.println(dongguangming.equals(dgm)+","+dongguangming.hashCode()+","+dgm.hashCode());
     HashSet<Person> ps = new HashSet<Person>();
     ps.add(dongguangming);
     ps.add(dongguangmingdgm);
     ps.add(gaoyafei);
     System.out.println(ps);
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是："+name + ",年齡是：" +age;
        }
        
        //複寫Object類中默認的equals（）
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //若是是同一個對象，返回ture
        if(this ==obj){
        return true;
        }
        
        //判斷是否爲同一類型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

輸出結果：

true,6413875,21174459

[名字是：dongguangming,年齡是：25, 名字是：gaoyafei,年齡是：25, 名字是：dongguangming,年齡是：25]

（注：有重複元素dongguangming,年齡是：25兩次）

分析：

咱們重寫了Person的equals()。可是，很奇怪的發現：HashSet中仍然有重複元素：dongguangming和 dgm。爲何會出現這種狀況呢？

這是由於雖然dongguangming 和 dgm的內容相等，可是它們的hashCode()不等；因此，HashSet在添加dongguangming和dgm的時候，認爲它們不相等。

下面，咱們同時覆蓋equals() 和 hashCode()方法。簡要代碼以下：

public static void main(String[] args) {
     Person dongguangming = new Person("dongguangming", 25);
     Person dgm= new Person("dongguangming", 25);
     Person gaoyafei = new Person("gaoyafei", 25);
     Person dgm_DGM = new Person("DONGGUANGMING", 25);
     System.out.println(dongguangming.equals(dgm)+","+dongguangming.hashCode()+","+dgm.hashCode());
     System.out.println(dongguangming.equals(dgm_DGM)+","+dongguangming.hashCode()+","+dgm_DGM.hashCode());
     HashSet<Person> ps = new HashSet<Person>();
     ps.add(dongguangming);
     ps.add(dongguangmingdgm);
     ps.add(gaoyafei);
     ps.add(dgm_DGM);
     System.out.println(ps);
    }   
    private static class Person {        
        String name;     
        int age;   
        public Person(String name, int age) 
        {            
        this.name = name;            
        this.age = age;
        }        
        public String toString() 
        {            
        return "名字是："+name + ",年齡是：" +age;
        }
        
        //複寫Object類中默認的hashCode()方法
	public int hashCode(){
	    return name.toUpperCase().hashCode()*age;
	}
		
        //複寫Object類中默認的equals（）
        public boolean equals(Object obj){
        if(obj == null){
        return false;
        }
        
        //若是是同一個對象，返回ture
        if(this ==obj){
        return true;
        }
        
        //判斷是否爲同一類型
        if (this.getClass()!=obj.getClass())
        {
        return false;
        }
        
        Person p = (Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }

輸出結果：

true,-1515325931,-1515325931

false,-1515325931,-1515325931

[名字是：DONGGUANGMING,年齡是：25, 名字是：dongguangming,年齡是：25, 名字是：gaoyafei,年齡是：25]

（注：無重複元素dongguangming,年齡是：25一次）

結果分析：

這下，equals()生效了，HashSet中沒有重複元素。
比較dongguangming和dgm，咱們發現：它們的hashCode()相等，經過equals()比較它們也返回true。因此，dongguangming和dgm被視爲相等。
比較dongguangming和dgm_DGM，咱們發現：雖然它們的hashCode()相等；可是，經過equals()比較它們返回false。因此，dongguangming和dgm_DGM被視爲不相等。