<span style="font-family:SimSun;font-size:12px;">public class EqualsTest {
    public static void main(String[] args) {
        Fish f1 = new Fish(1, "blue");
        Fish f2 = new Fish(1, "blue");

        System.out.println(f1 == f2);
        System.out.println(f1.equals(f2));
    }
}

——————執行結果為——————
false
false</span>
 

由此可見 equals方法的本意是比較引用地址是否相等，指向同一個物件

這些類有：java.io.file   java.util.Data    java.lang.string     包裝類(Intger   Double)  

<span style="font-family:SimSun;font-size:12px;">public class EqualsTest {
    public static void main(String[] args) {
        String s1=new String("sss");
        String s2=new String("sss");
        
        System.out.println(s1==s2);
        System.out.println(s1.equals(s2));
    }
}
--------------------執行結果為----------
false
true</span>
 

可見在 String中 equals方法被覆蓋，使其意義變為比較 內容是否相等

一、為什麼equals()方法要重寫？

判斷兩個物件在邏輯上是否相等，如根據類的成員變數來判斷兩個類的例項是否相等，而繼承Object中的equals方法只能判斷兩個引用變數是否是同一個物件。這樣我們往往需要重寫equals()方法。

我們向一個沒有重複物件的集合中新增元素時，集合中存放的往往是物件，我們需要先判斷集合中是否存在已知物件，這樣就必須重寫equals方法。

二、怎樣重寫equals()方法？

• 重寫equals方法的要求：
  1.自反性：對於任何非空引用x，x.equals(x)應該返回true。
  2.對稱性：對於任何引用x和y，如果x.equals(y)返回true，那麼y.equals(x)也應該返回true。
  3.傳遞性：對於任何引用x、y和z，如果x.equals(y)返回true，y.equals(z)返回true，那麼x.equals(z)也應該返回true。
  4.一致性：如果x和y引用的物件沒有發生變化，那麼反覆呼叫x.equals(y)應該返回同樣的結果。
  5.非空性：對於任意非空引用x，x.equals(null)應該返回false。

<span style="font-family:SimSun;font-size:12px;">public boolean equals(Object obj) {  
    if(this == obj)  
        return false;  
    if(obj == null)  
        return false;  
    if(getClass() != obj.getClass() )  
        return false;  
    MyClass other = (MyClass)obj;  
    if(str1 == null) {  
         if(obj.str1 != null) {  
              return false;  
         }  
    }else if (!str1.equals(other.str1) )  
             return false;  
     }  
    if(var1 != other.var1)  
        return false;  
    return true;  
</span>

 如果子類中增加了新特性，同時保留equals方法，這時比較複雜。

接下來我們通過例項來理解上面的約定。我們首先以一個簡單的非可變的二維點類作為開始： 
public class Point{ 
　　private final int x; 
　　private final int y; 
　　public Point(int x, int y){ 
　　　　this.x = x; 
　　　　this.y = y; 
　　} 

　　public boolean equals(Object o){ 
　　　　if(!(o instanceof Point)) 
　　 　　　return false; 
　　　　Point p = (Point)o; 
　　　　　　return p.x == x && p.y == y; 
　　} 

} 


假設你想要擴充套件這個類，為一個點增加顏色資訊： 
public class ColorPoint extends Point{ 
　　private Color color; 
　　public ColorPoint(int x, int y, Color color){ 
　　　　super(x, y); 
　　　　this.color = color; 
　　} 

　　//override equasl() 

　　public boolean equals(Object o){ 
　　　　if(!(o instanceof ColorPoint)) 
　　　　　return false; 
　　　　ColorPoint cp = (ColorPoint)o; 
　　　　return super.equals(o) && cp.color==color; 
　　} 
} 


　　我們重寫了equals方法，只有當實參是另一個有色點，並且具有同樣的位置和顏色的時候，它才返回true。可這個方法的問題在於，你在比較一個普通點和一個有色點，以及反過來的情形的時候，可能會得到不同的結果： 
public static void main(String[] args){ 
　　Point p = new Point(1, 2); 
　　ColorPoint cp = new ColorPoint(1, 2, Color.RED); 
　　System.out.println(p.equals(cp)); 
　　System.out.println(cp.eqauls(p)); 
} 

執行結果： 
true   
false 
這樣的結果顯然違反了對稱性，你可以做這樣的嘗試來修正這個問題：讓ColorPoint.equals在進行“混合比較”的時候忽略顏色資訊： 
public boolean equals(Object o){ 
　　if(!(o instanceof Point)) 
　　　　return false; 
　　//如果o是一個普通點，就忽略顏色資訊 
　　if(!(o instanceof ColorPoint)) 
　　　　return o.equals(this); 
　　//如果o是一個有色點，就做完整的比較 
　　ColorPoint cp = (ColorPoint)o; 
　　return super.equals(o) && cp.color==color; 
} 

這種方法的結果會怎樣呢？讓我們先來測試一下： 
public static void main(String[] args){ 
　　ColorPoint p1 = new ColorPoint(1, 2, Color.RED); 
　　Point p2 = new Point(1, 2); 
　　ColorPoint p3 = new ColorPoint(1, 2, Color.BLUE); 
　　System.out.println(p1.equals(p2)); 
　　System.out.println(p2.equals(p1)); 
　　System.out.println(p2.equals(p3)); 
　　System.out.println(p1.eqauls(p3)); 
} 

執行結果： 
true 
true 
true 
false 

　　這種方法確實提供了對稱性，但是卻犧牲了傳遞性(按照約定，p1.equals(p2)和p2.eqauals(p3)都返回true，p1.equals(p3)也應返回true)。要怎麼解決呢？

事實上，這是面嚮物件語言中關於等價關係的一個基本問題。要想在擴充套件一個可例項化的類的同時，既要增加新的特徵，同時還要保留equals約定，沒有一個簡單的辦法可以做到這一點。新的解決辦法就是不再讓ColorPoint擴充套件Point，而是在ColorPoint中加入一個私有的Point域，以及一個公有的檢視(view)方法： 
public class ColorPoint{ 
　　private Point point; 
　　private Color color; 
　　public ColorPoint(int x, int y, Color color){ 
　　　　point = new Point(x, y); 
　　　　this.color = color; 
　　} 

　　//返回一個與該有色點在同一位置上的普通Point物件 
　　public Point asPoint(){ 
　　　　return point; 
　　} 

　　public boolean equals(Object o){ 
　　　　if(o == this) 
　　　　　return true; 
　　　　if(!(o instanceof ColorPoint)) 
　　　　　return false; 
　　　　ColorPoint cp = (ColorPoint)o; 
　　　　return cp.point.equals(point)&& 
　　　　　　　　　　　　　cp.color.equals(color); 

　　} 
} 

　　還有另外一個解決的辦法就是把Point設計成一個抽象的類(abstract class)，這樣你就可以在該抽象類的子類中增加新的特徵，而不會違反equals約定。因為抽象類無法建立類的例項，那麼前面所述的種種問題都不會發生。
重寫equals方法的要點： 
1. 使用==操作符檢查“實參是否為指向物件的一個引用”。

2.判斷實參是否為null
3. 使用instanceof操作符檢查“實參是否為正確的型別”。 
4. 把實參轉換到正確的型別。 
5. 對於該類中每一個“關鍵”域，檢查實參中的域與當前物件中對應的域值是否匹 
　　配。對於既不是float也不是double型別的基本型別的域，可以使用==操作符 
　　進行比較；對於物件引用型別的域，可以遞迴地呼叫所引用的物件的equals方法； 
　　對於float型別的域，先使用Float.floatToIntBits轉換成int型別的值， 
　　然後使用==操作符比較int型別的值；對於double型別的域，先使用 
　　Double.doubleToLongBits轉換成long型別的值，然後使用==操作符比較 
　　long型別的值。 
6. 當你編寫完成了equals方法之後，應該問自己三個問題：它是否是對稱的、傳 
　　遞的、一致的？(其他兩個特性通常會自行滿足)如果答案是否定的，那麼請找到 
　　這些特性未能滿足的原因，再修改equals方法的程式碼。