重写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

反例：

破坏自反性

public class AntiReflexive {

    private String str;
    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }
    
    public boolean equals(Object o) {
        if (!(o instanceof AntiReflexive)) {
            return false;
        }
        
        AntiReflexive ar = (AntiReflexive)o;
        return this.str.equals(ar.str.toLowerCase());   // tolowercase 导致了自反性的破坏
    }
    
    public static void main(String[] args) {
        AntiReflexive ar1 = new AntiReflexive();
        ar1.setStr("Hello world");
        
        System.out.println(ar1.equals(ar1));
    }
}

破坏对称性

/**
 * 代码来自  effective java
 */
public class AntiSymmetric {

    public static void main(String[] args) {
        CaseInsensitiveString cis = new CaseInsensitiveString("abc");
        String str = "abc";
        System.out.println(cis.equals(str));
        System.out.println(str.equals(cis));
    }
}

class CaseInsensitiveString {

    private String s;
    
    public CaseInsensitiveString(String s) {
        this.s = s;
    }
    
    public boolean equals(Object o) {
        if (o instanceof CaseInsensitiveString) {
            return s.equalsIgnoreCase(((CaseInsensitiveString)o).s);
        }
        
        if (o instanceof String) {        // 这个地方破坏了对称性，因为在String中不存在这样的逻辑，单向的
            return s.equalsIgnoreCase((String)o);
        }
        
        return false;
    }
}

破坏传递性

public class AntiTransitive {

    public static void main(String[] args) {
        ColorPoint x = new ColorPoint(10,  20, Color.red);
        Point y = new Point(10, 20);
        ColorPoint z = new ColorPoint(10,  20, Color.blue);
        
        System.out.println("x.equals(y) = " + x.equals(y));
        System.out.println("y.equals(z) = " + y.equals(z));
        System.out.println("x.equals(z) = " + x.equals(z));
    }
}

class Point {
    private int x;
    private 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 x == p.x && y ==  p.y;
    }
}

class ColorPoint extends Point {
    private Color color;
    
    public ColorPoint(int x, int y, Color color) {
        super(x, y);
        this.color = color;
    }
    
    public boolean equals(Object o) {
        if (!(o instanceof Point)) {
            return false;
        }
        
        if (!(o instanceof ColorPoint)) {
            return o.equals(this);            // 这个地方破坏了传递性
        }
        
        ColorPoint cp = (ColorPoint)o;
        
        return super.equals(o) && cp.color == this.color;
    }
}

在编写equals代码时，一些好的习惯是非常必要的

• 使用 == 判断对象是否就等于this，这样就保证了自反性，还提高了performance
• 使用instanceof 来判断这个对象是不是正确的类型，如果不是，就返回false
• 将参数强制转换为正确的类型，因为经过了instanceof的测试，索引放心的转吧
• 优先比较导致返回false的可能性比较大的字段，只要发现不一样就返回false
• 对于float和double类型的字段，使用Float.compare 或者 Double.compare 方法来比较
• 对于数组字段，遍历数组比较其中的每一项
• 不要比较冗余字段（比如多边形类型的面积字段，就不用比较） 
• 如果重写了equals，请重写hashcode