Effective Java 第九条：覆盖equals时总要覆盖hashCode

先来看一个例子：PhoneNumer类

public class PhoneNumber {
    private final int areaCode;
    private final int prefix;
    private final int lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        rangeCheck(areaCode , 999 ,"area code");
        rangeCheck(prefix , 999 ,"prefix");
        rangeCheck(lineNumber , 999 ,"line number");
        this.areaCode = areaCode;
        this.prefix = prefix;
        this.lineNumber = 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 obj) {
        if(obj == this)
            return true;
        if(!(obj instanceof PhoneNumber))
            return false;
        PhoneNumber p = (PhoneNumber) obj;
        return p.areaCode == areaCode &&
                p.prefix == prefix &&
                p.lineNumber == lineNumber;
    }
}

测试打印结果：

Map<PhoneNumber,String> map = new HashMap<PhoneNumber, String>();
        map.put(new PhoneNumber(707,867,77),"Jenny");
        System.out.println(map.get(new PhoneNumber(707,867,77)));

结果返回null。

在PhoneNumer类中重写hashCode():

@Override
    public int hashCode() {
        return 42;
    }

测试打印结果：

结果返回Jenny。

如果hashCode返回值定死为一个值，虽然确保了相等的对象总有相等的散列码，但是因为它使得每个对象都具有相同的散列码。因此每个对象都被映射到同一个散列桶中，使得散列表退化为链表。它使得本该以线性运行的程序编程平方级运行，对于规模很大的散列表而言，这会关系到散列表能否正常工作。我们需要解决的问题是“为不同的相等对象产生不同的散列码”，这就需要程序员自己计算散列码。具体解决办法见《Effective Java》第九条，针对本例给出一个解决办法：

重写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;
            hashCode = result;
        }
        return hashCode;
    }