重寫equals方法

咱們都知道，==是用來比較引用的（物理上的相等），而equals方法是用來比較值的（邏輯上的相等），在許多時候須要重寫equals方法來實現咱們的需求，好比把對象放到容器中，而後去查找對象。

在重寫equals 方法時要遵循一些契約：

• 自反性：對於非空引用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
• 持久性：對於非空引用x和y，若是x.equals(y) 爲true，那麼當在x和y並未被修改的狀況下，不管執行多少次x.equals(y)，這個結果都爲true
• null-false： 對於非空引用x，x.equals(null) 始終爲false

 

反例：

破壞自反性

1 public class AntiReflexive {
 2 
 3     private String str;
 4     public String getStr() {
 5         return str;
 6     }
 7 
 8     public void setStr(String str) {
 9         this.str = str;
10     }
11     
12     public boolean equals(Object o) {
13         if (!(o instanceof AntiReflexive)) {
14             return false;
15         }
16         
17         AntiReflexive ar = (AntiReflexive)o;
18         return this.str.equals(ar.str.toLowerCase());   // tolowercase 致使了自反性的破壞
19     }
20     
21     public static void main(String[] args) {
22         AntiReflexive ar1 = new AntiReflexive();
23         ar1.setStr("Hello world");
24         
25         System.out.println(ar1.equals(ar1));
26     }
27 }

 

破壞對稱性

1 /**
 2  * 代碼來自  effective java
 3  */
 4 public class AntiSymmetric {
 5 
 6     public static void main(String[] args) {
 7         CaseInsensitiveString cis = new CaseInsensitiveString("abc");
 8         String str = "abc";
 9         System.out.println(cis.equals(str));
10         System.out.println(str.equals(cis));
11     }
12 }
13 
14 class CaseInsensitiveString {
15 
16     private String s;
17     
18     public CaseInsensitiveString(String s) {
19         this.s = s;
20     }
21     
22     public boolean equals(Object o) {
23         if (o instanceof CaseInsensitiveString) {
24             return s.equalsIgnoreCase(((CaseInsensitiveString)o).s);
25         }
26         
27         if (o instanceof String) {        // 這個地方破壞了對稱性，由於在String中不存在這樣的邏輯，單向的
28             return s.equalsIgnoreCase((String)o);
29         }
30         
31         return false;
32     }
33 }

 

破壞傳遞性

1 public class AntiTransitive {
 2 
 3     public static void main(String[] args) {
 4         ColorPoint x = new ColorPoint(10,  20, Color.red);
 5         Point y = new Point(10, 20);
 6         ColorPoint z = new ColorPoint(10,  20, Color.blue);
 7         
 8         System.out.println("x.equals(y) = " + x.equals(y));
 9         System.out.println("y.equals(z) = " + y.equals(z));
10         System.out.println("x.equals(z) = " + x.equals(z));
11     }
12 }
13 
14 class Point {
15     private int x;
16     private int y;
17     
18     public Point(int x, int y) {
19         this.x = x;
20         this.y = y;
21     }
22     
23     public boolean equals(Object o) {
24         if (!(o instanceof Point)) {
25             return false;
26         }
27         
28         Point p = (Point)o;
29         
30         return x == p.x && y ==  p.y;
31     }
32 }
33 
34 class ColorPoint extends Point {
35     private Color color;
36     
37     public ColorPoint(int x, int y, Color color) {
38         super(x, y);
39         this.color = color;
40     }
41     
42     public boolean equals(Object o) {
43         if (!(o instanceof Point)) {
44             return false;
45         }
46         
47         if (!(o instanceof ColorPoint)) {
48             return o.equals(this);            // 這個地方破壞了傳遞性
49         }
50         
51         ColorPoint cp = (ColorPoint)o;
52         
53         return super.equals(o) && cp.color == this.color;
54     }
55 }

 

在編寫equals代碼時，一些好的習慣是很是必要的

• 使用 == 判斷對象是否就等於this，這樣就保證了自反性，還提升了performance
• 使用instanceof 來判斷這個對象是否是正確的類型，若是不是，就返回false
• 將參數強制轉換爲正確的類型，由於通過了instanceof的測試，索引放心的轉吧
• 優先比較致使返回false的可能性比較大的字段，只要發現不同就返回false
• 對於float和double類型的字段，使用Float.compare 或者 Double.compare 方法來比較
• 對於數組字段，遍歷數組比較其中的每一項
• 不要比較冗餘字段（好比多邊形類型的面積字段，就不用比較） 
• 若是重寫了equals，請重寫hashcode