Java中equals()和hashCode()的使用

在Java语言中，equals()和hashCode()两个函数的使用是紧密配合的，你要是自己设计其中一个，就要设计另外一个。在多数情况 下，这两个函数是不用考虑的，直接使用它们的默认设计就可以了。但是在一些情况下，这两个函数最好是自己设计，才能确保整个程序的正常运行。最常见的是当 一个对象被加入收集对象（collection object）时，这两个函数必须自己设计。更细化的定义是：如果你想将一个对象A放入另一个收集对象B里，或者使用这个对象A为查找一个元对象在收集对 象B里位置的钥匙，并支持是否容纳，删除收集对象B里的元对象这样的操作，那么，equals()和hashCode()函数必须开发者自己定义。其他情 况下，这两个函数是不需要定义的。

equals():

它是用于进行两个对象的比较的，是对象内容的比较，当然也能用于进行对象参阅值的比较。什么是对象参阅值的比较？就是两个参阅变量的值得比较，我们 都知道参阅变量的值其实就是一个数字，这个数字可以看成是鉴别不同对象的代号。两个对象参阅值的比较，就是两个数字的比较，两个代号的比较。这种比较是默 认的对象比较方式，在Object这个对象中，这种方式就已经设计好了。所以你也不用自己来重写，浪费不必要的时间。

对象内容的比较才是设计equals()的真正目的，Java语言对equals()的要求如下，这些要求是必须遵循的。否则，你就不该浪费时间：

• 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
• 反射性：x.equals(x)必须返回是“true”。
• 类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
• 还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
• 任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

hashCode():
这 个函数返回的就是一个用来进行赫希操作的整型代号，请不要把这个代号和前面所说的参阅变量所代表的代号弄混了。后者不仅仅是个代号还具有在内存中才查找对 象的位置的功能。hashCode()所返回的值是用来分类对象在一些特定的收集对象中的位置。这些对象是HashMap, Hashtable, HashSet，等等。这个函数和上面的equals()函数必须自己设计，用来协助HashMap, Hashtable, HashSet，等等对自己所收集的大量对象进行搜寻和定位。

这些收集对象究竟如何工作的，想象每个元对象hashCode是一个箱子的 编码，按照编码，每个元对象就是根据hashCode()提供的代号归入相应的箱子里。所有的箱子加起来就是一个HashSet，HashMap，或 Hashtable对象，我们需要寻找一个元对象时，先看它的代码，就是hashCode()返回的整型值，这样我们找到它所在的箱子，然后在箱子里，每 个元对象都拿出来一个个和我们要找的对象进行对比，如果两个对象的内容相等，我们的搜寻也就结束。这种操作需要两个重要的信息，一是对象的 hashCode()，还有一个是对象内容对比的结果。

hashCode()的返回值和equals()的关系如下：

• 如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。
• 如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。

为什么这两个规则是这样的，原因其实很简单，拿HashSet来说吧，HashSet可以拥有一个或更多的箱子，在同一个箱子中可以有一个 或更多的独特元对象（HashSet所容纳的必须是独特的元对象）。这个例子说明一个元对象可以和其他不同的元对象拥有相同的hashCode。但是一个 元对象只能和拥有同样内容的元对象相等。所以这两个规则必须成立。

设计这两个函数所要注意到的：
如果你设计的对象类型并不使用于收集性对象，那么没有必要自己再设计这两个函数的处理方式。这是正确的面向对象设计方法，任何用户一时用不到的功能，就先不要设计，以免给日后功能扩展带来麻烦。

如果你在设计时想别出心裁，不遵守以上的两套规则，那么劝你还是不要做这样想入非非的事。我还没有遇到过哪一个开发者和我说设计这两个函数要违背前面说的两个规则，我碰到这些违反规则的情况时，都是作为设计错误处理。

当一个对象类型作为收集型对象的元对象时，这个对象应该拥有自己处理equals()，和/或处理hashCode()的设计，而且要遵守前面所说 的两种原则。equals()先要查null和是否是同一类型。查同一类型是为了避免出现ClassCastException这样的异常给丢出来。查 null是为了避免出现NullPointerException这样的异常给丢出来。

如果你的对象里面容纳的数据过多，那么这两个函数 equals()和hashCode()将会变得效率低。如果对象中拥有无法serialized的数据，equals()有可能在操作中出现错误。想象 一个对象x，它的一个整型数据是transient型（不能被serialize成二进制数据流）。然而equals()和hashCode()都有依靠 这个整型数据，那么，这个对象在serialization之前和之后，是否一样？答案是不一样。因为serialization之前的整型数据是有效的 数据，在serialization之后，这个整型数据的值并没有存储下来，再重新由二进制数据流转换成对象后，两者（对象在serialization 之前和之后）的状态已经不同了。这也是要注意的。

忽略缺省的 equals() 方法比较简单，但如果不违反对称（Symmetry）或传递性（Transitivity）需求，忽略已经忽略的 equals() 方法极其棘手。当忽略 equals() 时，您应该总是在 equals() 中包括一些Javadoc注释，以帮助那些希望能够正确扩展您的类的用户。

作为一个简单的例子，考虑以下类：

  class A {
    final B someNonNullField;
    C someOtherField;
    int someNonStateField;
  }

我们应如何编写该类的 equals() 的方法？这种方法适用于许多情况：

  public boolean equals(Object other) {
    // Not strictly necessary, but often a good optimization
    if (this == other)
      return true;
    if (!(other instanceof A))
      return false;
    A otherA = (A) other;
    return 
      (someNonNullField.equals(otherA.someNonNullField))
        && ((someOtherField == null) 
            ? otherA.someOtherField == null 
            : someOtherField.equals(otherA.someOtherField)));
  }

现在我们定义了 equals() ，我们必须以统一的方法来定义 hashCode() 。一种统一但并不总是有效的定义 hashCode() 的方法如下：

  public int hashCode() { return 0; }

这种方法将生成大量的条目并显著降低 HashMap s的性能，但它符合规范。一个更合理的 hashCode() 实施应该是这样：

  public int hashCode() { 
    int hash = 1;
    hash = hash * 31 + someNonNullField.hashCode();
    hash = hash * 31 
                + (someOtherField == null ? 0 : someOtherField.hashCode());
    return hash;
  }

下面是一个具体例子：

1. 设计equals()
　　[1]使用instanceof操作符检查“实参是否为正确的类型”。
　　[2]对于类中的每一个“关键域”，检查实参中的域与当前对象中对应的域值。
　　[2.1]对于非float和double类型的原语类型域，使用==比较；
　　[2.2]对于对象引用域，递归调用equals方法；
　　[2.3]对于float域，使用Float.floatToIntBits(afloat)转换为int，再使用==比较；
　　[2.4]对于double域，使用Double.doubleToLongBits(adouble) 转换为int，再使用==比较；
　　[2.5]对于数组域，调用Arrays.equals方法。
2.当改写equals()的时候，总是要改写hashCode()
　　根据一个类的equals方法（改写后），两个截然不同的实例有可能在逻辑上是相等的，但是，根据Object.hashCode方法，它们仅仅是两个对象。因此，违反了“相等的对象必须具有相等的散列码”。
3.设计hashCode()
　　[1]把某个非零常数值，例如17，保存在int变量result中；
　　[2]对于对象中每一个关键域f（指equals方法中考虑的每一个域）：
　　[2.1]boolean型，计算(f ? 0 : 1);
　　[2.2]byte,char,short型，计算(int);
　　[2.3]long型，计算(int) (f ^ (f>>>32));
　　[2.4]float型，计算Float.floatToIntBits(afloat);
　　[2.5]double型，计算Double.doubleToLongBits(adouble)得到一个long，再执行[2.3];
　　[2.6]对象引用，递归调用它的hashCode方法;
　　[2.7]数组域，对其中每个元素调用它的hashCode方法。

　　[3]将上面计算得到的散列码保存到int变量c，然后执行 result=37*result+c;

　　[4]返回result。

　　4.示例

　　下面的这个类遵循上面的设计原则，重写了类的equals()和hashCode()。

　　package com.zj.unit;

import java.util.Arrays;
public class Unit {
　　private short ashort;
　　private char achar;
　　private byte abyte;
　　private boolean abool;
　　private long along;
　　private float afloat;
　　private double adouble;
　　private Unit aObject;
　　private int[] ints;
　　private Unit[] units;
　　public boolean equals(Object o) {
　　　 if(o==this){
           return true;
       }
       if(!(o instanceof Unit)){
           return false;
       }
      Unit unit = (Unit) o;
      return unit.ashort == ashort
 　　　　　&& unit.achar == achar
 　　　　　&& unit.abyte == abyte
 　　　　　&& unit.abool == abool
 　　　　　&& unit.along == along
 　　　　　&& Float.floatToIntBits(unit.afloat) == Float
 　　　　　　　　 .floatToIntBits(afloat)
 　　　　　&& Double.doubleToLongBits(unit.adouble) == Double
 　　　　　　　　 .doubleToLongBits(adouble)
 　　　　　&& unit.aObject.equals(aObject)
       && equalsInts(unit.ints)
 　　　　　&& equalsUnits(unit.units);　　

   }
　　private boolean equalsInts(int[] aints) {
　　　 return Arrays.equals(ints, aints);
　　}
　　private boolean equalsUnits(Unit[] aUnits) {
　　　 return Arrays.equals(units, aUnits);
　　}
　　public int hashCode() {
　　　 int result = 17;
　　　 result = 37 * result + (int) ashort;
　　　 result = 37 * result + (int) achar;
　　　 result = 37 * result + (int) abyte;
　　　 result = 37 * result + (abool ? 0 : 1);
　　　 result = 37 * result + (int) (along ^ (along >>> 32));
　　　 result = 37 * result + Float.floatToIntBits(afloat);
　　　 long tolong = Double.doubleToLongBits(adouble);
　　　 result = 37 * result + (int) (tolong ^ (tolong >>> 32));
　　　 result = 37 * result + aObject.hashCode();
　　　 result = 37 * result + intsHashCode(ints);
　　　 result = 37 * result + unitsHashCode(units);
　　　 return result;
　　}
　　private int intsHashCode(int[] aints) {
　　　 int result = 17;
　　　 for (int i = 0; i < aints.length; i++)
　　　　　 result = 37 * result + aints[i];
　　　 return result;
　　}
　　private int unitsHashCode(Unit[] aUnits) {
　　　 int result = 17;
　　　 for (int i = 0; i < aUnits.length; i++)
　　　　　 result = 37 * result + aUnits[i].hashCode();
　　　 return result;
　　}
}