第9条：覆盖equals时总要覆盖hashCode

equals方法和hashCode方法均是Object对象的方法。Object中关于hashCode约定的规范如下：

1. 在应用程序的执行期间，只要对象的equals方法的比较操作所用到的信息没有被修改，那么对同一个对象调用多次，hashCode方法都必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中，每次执行所返回的整数可以不一致。
   2.如果两个对象根据equals(Object)方法比较是相等的，那么调用这两个对象中任意一个对象的hashCode方法都必须产生同样的整数结果。
   3.如果两个对象根据equals(Object)方法比较是不相等的，那么调用这两个对象中任意一个对象的hashCode方法，则不一定要产生不同的整数结果。但是程序员应该知道，给不相等的对象产生截然不同的整数结果，有可能提高散列表(hash table)的性能。

1.jpg

2.jpg

如果某个类违反Object的hashCode的通用约定，会导致该类无法结合所有基于散列的集合一起正常运转，如：HashMap、HashSet和HashTable。
覆盖equals方法而没有覆盖hashCode方法违反了约定的第2条：相等的对象必须具有相等的散列码。

如下示例：
package com.wuyafu.java.effective.hashcode;

import java.util.HashMap;
import java.util.Map;

public 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, "lineNumber");
    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;
}   
/**
 * @param args
 */
public static void main(String[] args) {
    // TODO Auto-generated method stub
    Map<PhoneNumber, String> m = 
                      new HashMap<PhoneNumber, String>();
    m.put(new PhoneNumber(408, 867, 5309), "Jenny");
    System.out.println(m.get(new PhoneNumber(408, 867, 5309)));
}

}
由于PhoneNumber类没有覆盖hashCode方法，从而导致两个相等的实例具有不相等的散列码，违反了hashCode的约定。

为解决这个问题，只需为PhoneNumber类提供一个适当的hashCode方法即可。
如下：
@Override
public int hashCode(){return 42;}

该方法确保了相等的对象总是具有同样的散列码。但是它也极为恶劣，因为它使得每个对象都具有同样的散列码。因此每个对象都被映射到同一个散列桶中，使散列表退化为链表。
一个好的散列函数通常倾向于“为不相等的对象产生不相等的散列码”，散列函数应该把集合中不相等的实例均匀地分布到所有可能的散列值上。实现这种理想状态很难，但如下方法可以接近理想状态：

3.jpg

在散列码的计算过程中，可以把冗余域排除在外。
在公式中result不能为0,17为任意选的值。
31为奇素数，有更好的性能

利用上述接近办法，修改PhoneNumber类的hashCode方法如下：
@Override
public int hashCode(){
int result = 17;
result = 31 * result + areaCode;
result = 31 * result + prefix;
result = 31 * result + lineNumber;
return result;
}

如果一个类是不可变的，并且计算散列码的开销也比较大，就应该考虑把散列码缓存在对象内部，而不是每次请求的时候都重新计算散列码。可以通过“延迟初始化”散列码的方式来实现，修改PhoneNumber类的hashCode方法如下：
private volatile int hashCode;
@Override
public int hashCode(){
int result = hashCode;
if (result == 0) {
result = 17;
result = 31* result + areaCode;
result = 31* result + prefix;
result = 31* result + lineNumber;
}
}

总结：当覆盖equals方法时，要覆盖hashCode方法，并且采用公式来将对象的关键域参与到散列码的计算中，确保不相同的对象在不同的散列桶中。若该类是不可变的，可以考虑使用“延迟初始化”散列码的方式。