Java重寫equals方法（重點講解）

時間  2019-12-13
標籤 java 重寫 equals 方法 重點 講解 欄目 Java 简体版
原文   原文鏈接

爲何equals()方法要重寫？html

判斷兩個對象在邏輯上是否相等，如根據類的成員變量來判斷兩個類的實例是否相等，而繼承Object中的equals方法只能判斷兩個引用變量是不是同一個對象。這樣咱們每每須要重寫equals()方法。java

咱們向一個沒有重複對象的集合中添加元素時，集合中存放的每每是對象，咱們須要先判斷集合中是否存在已知對象，這樣就必須重寫equals方法。數組

怎樣重寫equals()方法？緩存

重寫equals方法的要求：ide

一、自反性：對於任何非空引用x，x.equals(x)應該返回true。學習

二、對稱性：對於任何引用x和y，若是x.equals(y)返回true，那麼y.equals(x)也應該返回true。測試

三、傳遞性：對於任何引用x、y和z，若是x.equals(y)返回true，y.equals(z)返回true，那麼x.equals(z)也應該返回true。this

四、一致性：若是x和y引用的對象沒有發生變化，那麼反覆調用x.equals(y)應該返回一樣的結果。url

五、非空性：對於任意非空引用x，x.equals(null)應該返回false。spa

一、自反性原則

在JavaBean中，常常會覆寫equals方法，從而根據實際業務狀況來判斷兩個對象是否相等，好比咱們寫一個person類，根據姓名來判斷兩個person類實例對象是否相等。代碼以下：

 1 public class Person {
 2     private String name;
 3 
 4     public Person(String name) {
 5         this.name = name;
 6     }
 7 
 8     public String getName() {
 9         return name;
10     }
11 
12     public void setName(String name) {
13         this.name = name;
14     }
15 
16     @Override
17     public boolean equals(Object obj) {
18         if (obj instanceof Person) {
19             Person person = (Person) obj;
20             return name.equalsIgnoreCase(person.getName().trim());
21         }
22         return false;
23     }
24 
25     public static void main(String[] args) {
26         Person p1 = new Person("張三");
27         Person p2 = new Person("張三    ");
28         List<Person> list = new ArrayList<Person>();
29         list.add(p1);
30         list.add(p2);
31         System.out.println("是否包含張三：" + list.contains(p1));
32         System.out.println("是否包含張三：" + list.contains(p2));
33     }
34 }

list中含有這個生成的person對象，結果應該爲true，可是實際結果：這裏考慮了字符串空格的問題，去除先後的空格。

是否包含張三：true

是否包含張三：false

第二個爲何會是false呢？

緣由在於list中檢查是否含有元素時是經過調用對象的equals方法來判斷的，也就是說 contains（p2）傳遞進去會依次執行p2.equals(p1)、p2.equals(p2)，只要一個返回true，結果就是true。可是這裏p2.equals(p2)返回的是false？因爲咱們對字符先後進行了空格的切割形成p2.equals(p2)的比較其實是：「張三   」.equals（「張三」），一個有空格，一個沒有空格就出錯了。

這個違背了equals的自反性原則：對於任何非空引用x，x.equals(x)應該返回true。

這裏只要去掉trim方法就能夠解決。

二、對稱性原則

上面這個例子，還並非很好，若是咱們傳入null值，會怎麼樣呢？增長一條語句：Person p2=new Person(null);

結果：

是否包含張三：true
Exception in thread "main" java.lang.NullPointerException//空指針異常

緣由在執行p2.equals(p1)時，因爲p2的name是一個null值，因此調用name.equalsIgnoreCase()方法時就會報空指針異常。

這是在覆寫equals方法時沒有遵循對稱性原則：對於任何應用x,y的情形，若是想x.equals(y)返回true，那麼y.equals(x),也應該返回true。

應該在equals方法里加上是否爲null值的判斷：

 1 @Override
 2     public boolean equals(Object obj) {
 3         if (obj instanceof Person) {
 4             Person person= (Person) obj;
 5             if (person.getName() == null || name == null) {
 6                 return false;
 7             }else{
 8                 return name.equalsIgnoreCase(person.getName());
 9             }
10         }
11         return false;
12     }

三、傳遞性原則　　

如今咱們有一個Employee類繼承自person類：

 1 public class Employee extends Person{
 2     private int id;
 3   
 4   
 5     public int getId() {
 6         return id;
 7     }
 8     public void setId(int id) {
 9         this.id = id;
10     }
11     public Employee(String name,int id) {
12         super(name);
13         this.id = id;
14         // TODO Auto-generated constructor stub
15     }
16     @Override
17     public boolean equals(Object obj) {
18         if(obj instanceof Employee){
19             Employee e = (Employee)obj;
20             return super.equals(obj) && e.getId() == id;
21         }
22         return super.equals(obj);
23     }
24   
25     public static void main(String[] args){
26         Employee e1=new Employee("張三",12);
27         Employee e2=new Employee("張三",123);
28         Person p1 = new Person("張三");
29   
30         System.out.println(p1.equals(e1));
31         System.out.println(p1.equals(e2));
32         System.out.println(e1.equals(e2));
33     }
34 }

只有在name和ID都相同的狀況下才是同一個員工，避免同名同姓的。在main裏定義了，兩個員工和一個社會閒雜人員，雖然同名同姓但確定不是同一我的。運行結果應該三個都是false纔對。可是：

true

true

false

p1盡然等於e1,也等於e2，不是同一個類的實例也相等了？

由於p1.equals(e1)是調用父類的equals方法進行判斷的它使用instanceof關鍵字檢查e1是不是person的實例，因爲employee和person是繼承關係，結果就是true了。可是放過來就不成立，e1,e2就不等於p1，這也是違反對稱性原則的一個典型案例。

e1居然不等於e2？

e1.equals(e2)調用的是Employee的equals方法，不只要判斷姓名相同還有判斷工號相同，二者的工號不一樣，不相等時對的。可是p1等於e1,也等於e2，e1卻不等於e2，這裏就存在矛盾，等式不傳遞是由於違反了equals的傳遞性原則：對於實例對象x、y、z；若是x.equals(y)返回true，y.equals(z)返回true，那麼x.equals(z)也應該返回true。

上述狀況會發生是由於父類使用instanceof關鍵字(是不是這個特定類或者是它的子類的一個實例)，用來判斷是不是一個類的實例對象的，這很容易讓子類「鑽空子」。

想要解決也很簡單，使用getClass進行類型的判斷，person類的equals方法修改以下：

 1 @Override
 2     public boolean equals(Object obj) {
 3         if (obj != null && obj.getClass() == this.getClass()) {
 4             Person person= (Person) obj;
 5             if (person.getName() == null || name == null) {
 6                 return false;
 7             }else{
 8                 return name.equalsIgnoreCase(person.getName());
 9             }
10         }
11         return false;
12 }

四、必須覆寫hashCode方法這樣結果就是三個false。

覆寫equals方法就必須覆寫hashCode方法，這是Javaer都知道的。

緣由就是HashMap的底層處理機制是以數組的方式保存map條目的，這其中的關鍵是這個數組下標的處理機制：

依據傳入元素的hashCode方法的返回值決定其數組的下標，若是該數組位置上已經有了map條目，且與傳入的鍵值相等則不處理，若不相等則覆蓋；若是數組位置沒有條目，則插入，並加入到map條目的鏈表中。同理檢查鍵是否存在也是根據哈希嗎肯定文職，而後遍歷查找鍵值的。

那麼對象的hashCode方法返回的是什麼呢？

他是一個對象的哈希碼，是有Object類的本地方法生成的，確保每一個對象有一個哈希碼。

一、重寫equals方法實例   部分代碼參考http://blog.csdn.net/wangloveall/article/details/7899948

重寫equals方法的目的是判斷兩個對象的內容(內容能夠有不少，好比同時比較姓名和年齡，同時相同的纔是用一個對象)是否相同。

若是不重寫equals，那麼比較的將是對象的引用是否指向同一塊內存地址，重寫以後目的是爲了比較兩個對象的value值是否相等。特別指出利用equals比較八大包裝對象，（如int，float等）和String類（由於該類已重寫了equals和hashcode方法）對象時，默認比較的是值，在比較其它自定義對象時都是比較的引用地址。

package com.lk.C;

class User {
    private String name;
    private int age;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {  
        this.name = name;  
    }
    public String getName() {  
        return name;  
    }
    public boolean equals(Object obj) {  
        if(this == obj) {  
            return true;  
        }  
        if(null == obj) {  
            return false;  
        }  
        if(this.getClass() != obj.getClass()) {  
            return false;  
        }  

        User user = (User) obj;  
        if(this.name.equals(user.name)&&this.age == user.age) {  
            return true;  
        }  
        return false;  
    }  
    
}  

public class Test6 {  
    public static void main(String[] args) {  
        User userA = new User();  
        userA.setName("王明");
        userA.setAge(10);

        User userB = new User();  
        userB.setName("王明");
        userB.setAge(10);

        User userC = new User();  
        userC.setName("王亮");
        userC.setAge(10);

        System.out.println("userA equals userB:" + userA.equals(userB));  
        System.out.println("userA equals userC:" + userA.equals(userC));
    }  
}  
userA equals userB:true
userA equals userC:false

在Java中，問什麼說重寫了equals方法都要進而重寫Hashcode方法呢？

緣由以下：當equals此方法被重寫時，一般有必要重寫 hashCode 方法，以維護 hashCode 方法的常規協定，該協定聲明相等對象必須具備相等的哈希碼。以下：

(1)當obj1.equals(obj2)爲true時，obj1.hashCode() == obj2.hashCode()必須爲true

(2)當obj1.hashCode() == obj2.hashCode()爲false時，obj1.equals(obj2)必須爲false

hashcode是用於散列數據的快速存取，如利用HashSet/HashMap/Hashtable類來存儲數據時，都是根據存儲對象的hashcode值來進行判斷是否相同的。

這樣若是咱們對一個對象重寫了euqals，意思是隻要對象的成員變量值都相等那麼euqals就等於true，但不重寫hashcode，那麼咱們再new一個新的對象，當原對象.equals（新對象）等於true時，二者的hashcode倒是不同的，由此將產生了理解的不一致。

二、看看下面的三段程序

package com.lk.C;

public class Test7 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        System.out.print("基本類型a==b:");
        System.out.println(a == b);
        System.out.println("-----");
        
        String s1 = "abc";
        String s2 = "abc";
        System.out.print("String類型是s1==s2:");
        System.out.println(s1 == s2);
        System.out.println("-----");
        
        String s3 = new String("abc");
        String s4 = new String("abc");//能夠看出==比較的是棧的地址是否相同
        System.out.print("String類型用new String()是s1==s2:");
        System.out.println(s3 == s4);
        System.out.println(s1 == s3);
        System.out.println("-----");
        
        Integer i1 = 1;
        Integer i2 = 1;
        System.out.print("包裝類型是i1==i2:");
        System.out.println(i1 == i2);
        System.out.println("-----");
        
        Integer i3 = 128;
        Integer i4 = 128;//此時輸出false是由於Integer在-128-127之間會緩存，超出這個範圍就不會緩存了
        System.out.print("包裝類型是i3==i4:");
        System.out.println(i3 == i4);
        System.out.println("-----");
        
        Integer i5 = new Integer("1");
        Integer i6 = new Integer("1");
        System.out.print("包裝類型用new Integer()是i5==i6:");
        System.out.println(i5 == i6);//用new Integer()多少都不會緩存
        System.out.println("-----");
        
        A a1 = new A(1);
        A a2 = new A(1);
        A a3 = a2;
        System.out.print("普通引用類型a1 == a2：");
        System.out.println(a1 == a2);
        System.out.println(a2 == a3);//對象賦給新對象連地址都是相同的
        System.out.println("-----");
    }
}

class A{
    int i;
    public A(int i){
        this.i = i;
    }
}
基本類型a==b:true
-----
String類型是s1==s2:true
-----
String類型用new String()是s1==s2:false
false
-----
包裝類型是i1==i2:true
-----
包裝類型是i3==i4:false
-----
包裝類型用new Integer()是i5==i6:false
-----
普通引用類型a1 == a2：false
true
-----
package com.lk.C;

public class Test8 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("基本類型沒有equals方法");
        System.out.println("-----");
        
        String s1 = "abc";
        String s2 = "abc";
        System.out.print("String類型的equals方法:");
        System.out.println(s1.equals(s2));
        System.out.println("-----");
        
        String s3 = new String("abc");
        String s4 = new String("abc");//能夠看出比較equals方法比較的是堆裏的值是否相同
        System.out.print("String類型的new String()的equals方法：");
        System.out.println(s3.equals(s4));
        System.out.println("-----");
        
        System.out.print("String用==賦值和用new String()賦值的比較：");
        System.out.println(s1.equals(s3));
        System.out.println("-----");
        
        Integer i1 = 1;
        Integer i2 = 1;
        System.out.print("包裝類的equals方法：");
        System.out.println(i1.equals(i2));
        System.out.println("-----");
        
        Integer i3 = new Integer(1);
        Integer i4 = new Integer(1);
        System.out.print("包裝類的new Integer()用equals方法：");
        System.out.println(i3.equals(i4));
        System.out.println("-----");
        
        System.out.print("Integer用==賦值和用new Integer()賦值的比較：");
        System.out.println(i1.equals(i3));
        System.out.println("-----");
    }

}
基本類型沒有equals方法
-----
String類型的equals方法:true
-----
String類型的new String()的equals方法：true
-----
String用==賦值和用new String()賦值的比較：true
-----
包裝類的equals方法：true
-----
包裝類的new Integer()用equals方法：true
-----
Integer用==賦值和用new Integer()賦值的比較：true
-----
package com.lk.C;

public class Test9 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student s1 = new Student("阿坤",21);
        Student s2 = new Student("阿坤",21);
        Student s3 = new Student();
        Student s4 = new Student();
        Student s5 = s1;
        System.out.print("普通類對象的==非默認構造：");
        System.out.println(s1 == s2);
        System.out.println(s1 == s5);
        System.out.println("-----");
        
        System.out.print("普通類對象的equals非默認構造：");
        System.out.println(s1.equals(s2));
        System.out.println(s1.equals(s5));
        System.out.println("-----");
        
        System.out.print("普通類對象的==默認構造：");
        System.out.println(s3 == s4);
        System.out.println("-----");
        
        System.out.print("普通類對象的equals默認構造：");
        System.out.println(s3.equals(s4));
        System.out.println("-----");
        
        System.out.print("對普通對象的屬性進行比較equals：");
        System.out.println(s1.name.equals(s2.name));
        System.out.print("對普通對象的屬性進行比較==：");
        System.out.println(s1.name == s2.name);
    }

}
class Student{
    public String name;
    public int age;
    public Student(){
        
    }
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void test(){
        System.out.println(this.name);
        System.out.println(this.age);
    }
}
普通類對象的==非默認構造：false
true
-----
普通類對象的equals非默認構造：false
true
-----
普通類對象的==默認構造：false
-----
普通類對象的equals默認構造：false
-----
對普通對象的屬性進行比較equals：true
對普通對象的屬性進行比較==：true

從以上的三個程序能夠看出：

1)對於==：在簡單類型中(int等)，這能使用該方法進行比較，這種類型沒有equals方法，int的值是存在棧中的，==比較的是棧的內容是否相同。在String類型中，比較特殊，用String=「」；這種進行賦值時，兩個相同的值用==比較也是相同的。可是用new String()，賦值就不相同。說明String=「」時，java會檢查在堆中是否由相同的值，若是有，把新對象的地址也同老對象的地址賦爲相同，所以==比較會相同。可是new String()開闢的就是兩個棧，所以用==比較不會相同。對於包裝類，如Integer=「」；時，在-128-127會有緩存，請看上面程序。其餘的狀況與String相似。

2)對於equals：當時String類型或者是包裝類，如Integer時，比較的就是堆中的值，Integer也無緩存之說。對於普通類，equals比較的內存的首地址，這時候和==是同樣的，即比較兩邊指向的是否是同一個對象。詳細請見程序三。

原文連接：http://blog.csdn.net/likesetaria/article/details/51281498

原文連接：http://www.cnblogs.com/silence-hust/p/4510574.html

很好，很詳細的文章，感謝網友的分享，記錄下來只爲學習。

以上程序都是親自測試過。但願能對你們有幫助。

如下是一些在百度中找到的說法：http://zhidao.baidu.com/link?url=AMYxGo3NunWY7irH5XLPlHUa0ywvyqgYEAdDUMKJlQvklm686MC_D7ZjT3dX9BmuZWXXjWRV2QHelGJ8GzAxBK

java中，
(1)對於字符串變量來講,equal比較的兩邊對象的內容，因此內容相同返回的是true。
至於你沒問到的「==」，比較的是內存中的首地址，因此若是不是同一個對象，「==」不會返回true 而是false。
舉個簡單的例子，
String s1="abc", s2="abc";
String s3 =new String("abc");
String s4=new String("abc");
s1==s2 //true，
s1.equals(s2) //true,
s3.equals(s3) //true，equal比較的是內容
s3==s4//false，==比較的是首地址，因此是false
(2)對於非字符串變量，equals比較的內存的首地址，這時候和==是同樣的，即比較兩邊指向的是否是同一個對象，
即
Sample sa1 = new Sample();
Sample sa2 = new Sample();
sa1.equals(sa2) //false，由於不是同一對象 
注意，若是加上
sa1=sa2;
那麼
sa1.equals(sa2) //true
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程