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

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

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

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

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

   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类的实现如下： 

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》上的例子来说明了违反这一特性的后果： 

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;
    }
}

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

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。下面举例说明： 

 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函数。下面运行如下代码来测试： 

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()能够将其区分开来。下面是一段示例的代码： 

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

    }