EffectiveJava（9）覆盖equals是总要覆盖hashCode

覆盖equals是总要覆盖hashCode

通过散列函数将集合中不相等的实例均匀的分布在所有可能的散列值上

1.把某个非零的常数值保存在一个名为result的int类型变量中

2.对于对象中每个关键域f(指equals方法中涉及的每个域),完成以下步骤:

a.为该域计算int类型的散列码c

i.boolean – f?1:0;

ii.byte char short int – int(f);

iii.long – int(f^f>>>32);

iv.Float – Float.floatToIntBits(f);

v.double – Double.DoubleToLongBits(f); -> 2.a.iii

vi.如果该域是一个对象引用,并且该类的equals方法通过递归地调用equals方式来比较这个域

,则同样为这个域递归的调用hashCode.如果需要更复杂的比较,则为这个域计算一个”范式”

(canonical representation),然后针对这个范式调用hashCode.如果这个域的值为null,则返回0

(或者其他某个常数,但通常是0)

vii.如果该域是一个数组,则要把每一个元素当做单独的域来处理,也就是说,递归的应用上述规则,对每个

重要的元素计算散列码,然后根据步骤2.b的方法把这些散列值组合起来.如果数组域中的每个元素都很重要

,可以利用Arrays.hashCode方法

b.按照 result = 31 * result + c 把步骤2.a中计算得到的散列码c合并到result中

为什么要用31:他是一个奇素数.如果乘法为偶数,且乘法溢出,信息就会丢失,因为与2相乘等价于位移运算

3.返回result

4.相等的实例是否具有相等的散列码

优化
 * 如果一个类是不可变的,并且计算散列码的开销比较大,
 * 应该考虑把散列码缓存在对象内部,而不是每次请求的时候都重新计算散列码.
 * 如果你觉得这种类型的大多数对象会被用作散列键,就应该在创建实例的时候重新计算散列码.
 * 否则,可以选择 延迟初始化 散列码 一直到hashCode被第一次调用的时候才初始化

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

    /**
     * //让相等的实例生成相等的散列码
     * 不相等的pn分散到不同的散列桶中
     */
//  @Override
//  public int hashCode() {
//      int result = 17;
//      result = 31 * result + areaCode;
//      result = 31 * result + prefix;
//      result = 31 * result + lineNumber;
//      return result;
//  }

/**
 * 优化
 * 如果一个类是不可变的,并且计算散列码的开销比较大,
 * 应该考虑把散列码缓存在对象内部,而不是每次请求的时候都重新计算散列码.
 * 如果你觉得这种类型的大多数对象会被用作散列键,就应该在创建实例的时候重新计算散列码.
 * 否则,可以选择 延迟初始化 散列码 一直到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 result;
    }
}