Java hashcode方法编写技巧 —— 记住这3条约定

本文结合《Effective Java》第三章条目9《覆盖equals时总要覆盖hashCode》和自己的理解及实践，讲解了在覆盖hashCode时需要遵守的规范，文章发布于专栏Effective Java，欢迎读者订阅。

Java的hashCode方法，int hashCode()，没有入参，返回一个int，是每个对象都有的方法，这个方法有什么用？编写时需要注意什么？

hashCode方法有什么用

hashCode方法，主要应用于散列集合的桶存放和查找算法中，这样的集合包括HashMap、HashSet、HashTable等。

这些集合，在存放元素的时候，会根据元素的hashcode方法的返回值，决定元素要放在哪个桶里面，这样做的目的是提高查找的效率，在查找的时候，就可以根据对象的hashcode返回值，直接定位到对象在哪个桶里面，然后再到桶里面，去调用equals方法查找这个对象。关于equals方法的介绍，可以阅读专栏的另一篇文章  Java equals方法编写规范 —— 牢记这五条军规

编写hashCode方法时要遵守的三条约定

1、一物一桶：如果x.equals(y)==true，那么x.hashCode() == y.hashCode()。

2、不能换桶：在应用程序执行期间，只要对象的equals方法所用到的信息没有改变，那么对这个对象调用多次hashCode方法，会一直返回同一个整数。

3、一桶一物：如果x.equals(y)==false，那么x和y的hashCode方法，尽量要产生不一样的结果，但原则上可以产生一样的结果。也就是说，一个桶里面，可以放多个对象，但是，按照上一节所讲的，一个桶里的对象越多，在查找的时候就要花费更多的时间，散列表的性能会下降，如果一个桶里面放的对象过多，那么也就起不到hash集合的优势了。

为什么覆盖了equals方法后一定要覆盖hashcode方法

原因很简单，因为如果不覆盖，那么由于Object的hashCode方法会返回随意的一个整数，因此两个equals的对象，hashCode方法返回值不同，违反了上一节的第一条约定。

那么，重点来了，为什么我们要遵守第一条约定呢？

假设有一个PhoneNumber类，通过equals实现了自己的"逻辑相等"：

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

然后现在有这么一个调用方法：

    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)));
    }

我们可能期望他会返回"Jenny”，但是结果却是返回null。原因在于，前后两个new出来的对象，hashCode返回值不一样，因此，在put的时候，hashMap会把对象放到桶1，然后在get时，hashMap却去桶2寻找这个对象，自然就找不到这个对象了。

要修正这个问题，我们只需要编写一个hashCode方法即可，怎么编写一个好的hashCode方法呢？

一个例子  学习怎样编写高质量的hashcode方法

针对上一小节讲的例子，我们给它编写了一个hashCode方法：

	@Override
	public int hashCode() {
		int result = 17;
		result = 31 * result + areaCode;
		result = 31 * result + prefix;
		result = 31 * result + lineNumber;
		return result;
	}

这个方法，为了满足约定1和2，使用了equals方法用到的三个属性，利用这三个属性，去计算hashCode。看了这个方法，或许会有如下疑问，来，一个一个解答：

1、为什么要用乘法，直接把三个属性相加，然后返回，不行吗？

答：行是可行，但是很容易导致不equals的两个对象，hashCode相等，也就是说，很容易违反约定3,。为什么呢？假设这样写：

	@Override
	public int hashCode() {
		int result = areaCode + prefix + lineNumber;
		return result;
	}

那么对于new PhoneNumber(707, 867, 5309) 和 new PhoneNumber(706, 868, 5309)，这两个不相同的对象，hashCode是不是就相等了？所以，乘法的目的，是为了让散列值依赖于属性的顺序，降低不同对象产生相同的hashCode的概率。

2、为什么要用31去乘？

《Effective Java》给的解释是：

a. 31有一个很好的特性，即用移位和减法代替乘法，31*i == (i<<5)-i，JVM会自动做这个优化

b. 31是奇素数，如果使用偶数，并且乘法溢出，信息就会丢失（这一点不是很懂）

3、如果属性不是int，而是long或者其他的怎么办？

原则很简单，就是把不是int的属性，转为int属性，并且保证不容易重复。

比如:

long类型的属性f，可以这样(int)(f^(f>>>32))

float类型：Float.floatToIntBits(f)

String类型：直接调用它的hashCode方法

依此类推...

总结

hashCode方法主要用在散列集合的元素存放和查找算法中。

hashCode方法要遵守三条约定：一物一桶，不能换桶，一桶一物。

覆盖equals方法之后一定要覆盖hashCode方法。

编写hashCode方法时，牢记一个数字——31，一个运算法——乘法，一个原则——转为int。