对java中equals和hashCode函数的一些理解1（转）-CSDN博客

本文链接：https://blog.csdn.net/wodedipanxia/article/details/83739988

JDK的java.lang.Object类中实现了equals函数，其定义说明如下：

其具体的实现代码如下所示：

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

从上面的代码中可以看出，Object类的equals实现只是简单地调用了“==”运算符，也即定义中说明的，对于两个非空对象X和Y，有且仅当X和Y指向同一个对象时该函数才返回true。由于Object类是java中所有类的超类，因而其它任何类都默认继承了此函数。在大多数情况下，此默认的实现方式是合适的，因为任一个类本质上都是唯一的；但是对于那些表示“值”的类(如Integer、String等)，它们引入了自己特有的“逻辑相等”的概念，此时就必须修改equals函数的实现。
例如java.lang.String类的实现如下：

    Java代码 
  
   public boolean equals(Object anObject) {  
       if (this == anObject) {  
    return true;  
}  
if (anObject instanceof String) {  
    String anotherString = (String)anObject;  
    int n = count;  
    if (n == anotherString.count) {  
    char v1[] = value;  
    char v2[] = anotherString.value;  
    int i = offset;  
    int j = anotherString.offset;  
    while (n-- != 0) {  
        if (v1[i++] != v2[j++])  
        return false;  
    }  
    return true;  
    }  
}  
return false;  
   }  

而java.lang.Integer类的实现如下：

    Java代码 
  
public boolean equals(Object obj) {  
    if (obj instanceof Integer) {  
        return value == ((Integer)obj).intValue();  
    }  
    return false;  
    }  

      String类的equals实现使得当两个String对象所表示的字符串的值是一样的时候就能返回true；而Integer类则当两个Integer对象所持有的整数值是一样的时候就能返回true。
      因此，当我们我们自己编写的类需要引入“逻辑相等”的概念，且其超类又没有改写equals的实现时，我们就必须实现自己的equals函数。在上面Object类中关于equals函数的说明中，定义了5条改写equals函数所必须遵守的规范。其中第1条自反性(reflexivity)和第5条通常能够自行满足。下面我们重点介绍下第2点对称性(symmetric)、第3点传递性(transitive)和第4点一致性(consistent)。
      对称性
即对于任意两个引用值X和Y，X.equals(Y) 和 Y.equals(X) 返回的结果必须是一致的。下面引用《effect java》上的例子来说明了违反这一特性的后果：

    Java代码 
  
public class CaseInsensitiveString {  
      
    private String s;  
      
    public boolean equals(Object obj){  
        if(obj instanceof CaseInsensitiveString)  
            return s.equalsIgnoreCase(((CaseInsensitiveString)obj).s);  
        if(obj instanceof String)  
            return s.equalsIgnoreCase((String)obj);  
        return false;  
    }  
}  

然后我们定义如下的类来进行测试：

    Java代码 
  
public void test(){  
    CaseInsensitiveString cis = new CaseInsensitiveString("Value");  
    String s = "Value";  
    List list = new ArrayList();  
    list.add(cis);  
    System.out.println(cis.equals(s));  
    System.out.println(s.equals(cis));  
    System.out.println(list.contains(s));  
}  

运行test(),第一条语句的输出为true，而后两条为false。因为CaseInsensitiveString类中equals函数对String对象的比较也可能返回true，只要其大小写不敏感的字符串值相等；而在String类中对任何非String对象都返回false，这样CaseInsensitiveString的实现就违反了对称性，从而导致了第三条语句也返回了意想不到的结果false。这是因为ArrayList的contains函数实现是用实参s对list中每一个对象调用equals函数，若有equals函数返回true，则contains返回true；因而在这里contains函数必然返回false。因此，如果违反了对称性，则可能会得到意料之外的结果。解决此问题的一个办法就是在CaseInsensitiveString类的equals函数中对Stirng对象的比较无论值是否一致都返回false。
传递性
即对于任意的引用值X、Y和Z，如果 X.equals(Y) 和 Y.equals(Z) 都返回true，则 X.equals(Z) 也一定返回true。下面举例说明：

    Java代码 
  
 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 obj) {  
        if (!(obj instanceof Point))  
            return false;  
        Point p = (Point) obj;  
        return p.x == x && p.y == y;  
    }  
}  
  
public class ColorPoint extends Point {  
  
    private int z;  
  
    public ColorPoint(int x, int y, int z) {  
        super(x, y);  
        this.z = z;  
    }  
  
    public boolean equals(Object obj) {  
        if (!(obj instanceof ColorPoint))  
            return false;  
        ColorPoint cp = (ColorPoint) obj;  
        return super.equals(obj) && cp.z == this.z;  
    }  
}  

在上面的代码中定义了类Point及其子类ColorPoint，并分别改写了equals函数。下面运行如下代码来测试：

    Java代码 
  
ColorPoint cp1 = new ColorPoint(1,2,3);  
ColorPoint cp2 = new ColorPoint(1,2,4);  
Point p = new Point(1,2);  
System.out.println(cp1.equals(p));  
System.out.println(p.equals(cp2));  
System.out.println(cp1.equals(cp2));  

结果前两条语句输出“true”，而最后一条语句输出为“false”；从而违反了传递性规范。其主要原因是在基类的equals函数中并未对子类加以区分，从而使得基类与子类之间的比较也能返回true。要解决此方法，《effect java》上提供了“复合代替继承”的方法；另外，如果可以将基类和子类视为不等的话，使用 getClass()函数代替 instanceof 运算符进行比较可以很好的解决这一问题。getClass()会返回此对象的运行期类(runtime class)，因为基类和子类属于不同的class，getClass()能够将其区分开来。下面是一段示例的代码：

    Java代码 
  
public boolean equals(Object obj) {  
        if(obj.getClass() != this.getClass())  
            return false;  
        Point p = (Point) obj;  
        return p.x == x && p.y == y;  
          
    }  