为什么覆盖equals时，总要覆盖hashCode?
原因是，根据Object规范：
如果两个对象根据equals(Object)方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
如果违反这个规定，那么，在使用应用了散列码的集合(HashMap,HashSet,Hashtable)时，就会出现问题。
也就是，两个相等的对象，必须要有相等的散列码(hashCode)。两个对象，进行比较的时候，使用的关键域是一样的，然后，使用这些关键域作为参数来生成散列码。两个对象相应的关键域的值相等，那么，使用相等的关键域，使用同样的生成方法，那么，生成出来的散列码是相等的
两个对象相等，那么，它们的hashCode是相等的么？
答：是的。根据Object规范，这是必须满足的。
两个对象的hashCode相等，那么这两个对象是相等的么？
答：不一定。因为，equals的实现，有可能是使用其它方式，未必只是简单地比较hashCode方法中用到的关键域。所以，不能根据对象的hashCode来判定两个对象是否相等。
两个对象根据equals(Object)方法进行比较，它们不相等，那么，这两个对象的hasoCde一定是不同的么？
答：不一定。同样的道理，因为equals方法的实现，未必只是简单地比较hashCode方法中用到的关键域的值。
hashCode的生成方式：
使用---HashCodeBuilder，该类是参考<<effective java>>中描述的规则实现的。
例子：
import java.util.HashMap;
import java.util.Map; public final class PhoneNumber {
private final short areaCode ;
private final short prefix ;
private final short lineNumber ; public PhoneNumber( int areaCode, int prefix, int lineNumber) {
rangeCheck(areaCode, 999, "area code");
rangeCheck(prefix, 999, "prefix" );
rangeCheck(lineNumber, 9999, "line number");
this. areaCode = ( short) areaCode;
this. prefix = ( short) prefix;
this. lineNumber = (short ) lineNumber;
} private static void rangeCheck(int arg, int max, String name) {
if (arg < 0 || arg > max)
throw new IllegalArgumentException(name + ": " + arg);
} @Override
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof PhoneNumber))
return false;
PhoneNumber pn = (PhoneNumber) o;
return pn. lineNumber == lineNumber && pn.prefix == prefix && pn. areaCode == areaCode;
} // Broken - no hashCode method! // A decent hashCode method - Page 48
// @Override public int hashCode() {
// int result = 17;
// result = 31 * result + areaCode;
// result = 31 * result + prefix;
// result = 31 * result + lineNumber;
// return result;
// } // Lazily initialized, cached hashCode - Page 49
// private volatile int hashCode; // (See Item 71)
//
// @Override public int hashCode() {
// int result = hashCode;
// if (result == 0) {
// result = 17;
// result = 31 * result + areaCode;
// result = 31 * result + prefix;
// result = 31 * result + lineNumber;
// hashCode = result;
// }
// return result;
// } public static void main(String[] args) {
Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();
m.put (new PhoneNumber(707, 867, 5309), "Jenny");
System.out.println(m.get( new PhoneNumber(707, 867, 5309)));
}
}
---------------------------------------------
输出结果是：
null
原因：在覆盖equals方法的时候，没有覆盖hashCode方法。PhoneNumber作为HashMap的K，在main方法中，生成了两个PhoneNumber实例，这两个PhoneNumber实例通过equals方法比较是相等的。但是，PhoneNumber，并没有覆盖hashCode方法，所以，这两个实例具备不同的hashCode。现在要做的就是，覆盖hashCode方法，然后，使通过equals比较相等的两个PhoneNumber实例返回相等的hashCode。
HashCode生成方式，使用HashCodeBuilder:
下面的代码添加了一个覆盖的hashCode方法，输出结果，就找到了Jenny。
public final class PhoneNumber {
private final short areaCode ;
private final short prefix ;
private final short lineNumber ;
public PhoneNumber( int areaCode, int prefix, int lineNumber) {
rangeCheck(areaCode, 999, "area code");
rangeCheck(prefix, 999, "prefix" );
rangeCheck(lineNumber, 9999, "line number");
this. areaCode = ( short) areaCode;
this. prefix = ( short) prefix;
this. lineNumber = (short ) lineNumber;
}
private static void rangeCheck(int arg, int max, String name) {
if (arg < 0 || arg > max)
throw new IllegalArgumentException(name + ": " + arg);
}
@Override
public boolean equals(Object o) {
if (o == this)
return true;
if (!(o instanceof PhoneNumber))
return false;
PhoneNumber pn = (PhoneNumber) o;
return pn. lineNumber == lineNumber && pn.prefix == prefix && pn. areaCode == areaCode;
}
@Override
public int hashCode() {
return new HashCodeBuilder(17, 37).append(lineNumber).append(prefix ).append(areaCode)
.toHashCode();
}
// Broken - no hashCode method!
// A decent hashCode method - Page 48
// @Override public int hashCode() {
// int result = 17;
// result = 31 * result + areaCode;
// result = 31 * result + prefix;
// result = 31 * result + lineNumber;
// return result;
// }
// Lazily initialized, cached hashCode - Page 49
// private volatile int hashCode; // (See Item 71)
//
// @Override public int hashCode() {
// int result = hashCode;
// if (result == 0) {
// result = 17;
// result = 31 * result + areaCode;
// result = 31 * result + prefix;
// result = 31 * result + lineNumber;
// hashCode = result;
// }
// return result;
// }
public static void main(String[] args) {
Map<PhoneNumber, String> m = new HashMap<PhoneNumber, String>();
m.put(new PhoneNumber(707, 867, 5309), "Jenny");
System.out.println(m.get( new PhoneNumber(707, 867, 5309)));
}
}
确定关键域，关键域指的是覆盖的equals方法中涉及到的每个域；然后，使用这些关键域，作为参数，用它们生成一个hashCode。这个可以通过HashCodeBuilder来实现，具体参照上述代码。