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

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

hashCode方法有什么用

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

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

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

一、一物一桶：若是x.equals(y)==true，那么x.hashCode() == y.hashCode()。
性能

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

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

为何覆盖了equals方法后必定要覆盖hashcode方法

缘由很简单，由于若是不覆盖，那么因为Object的hashCode方法会返回随意的一个整数，所以两个equals的对象，hashCode方法返回值不一样，违反了上一节的第一条约定。this

那么，重点来了，为何咱们要遵照第一条约定呢？spa

假设有一个PhoneNumber类，经过equals实现了本身的"逻辑相等"：
.net

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。看了这个方法，或许会有以下疑问，来，一个一个解答：

一、为何要用乘法，直接把三个属性相加，而后返回，不行吗？

答：行是可行，可是很容易致使不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的几率。

二、为何要用31去乘？

《Effective Java》给的解释是：

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

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

三、若是属性不是int，而是long或者其余的怎么办？

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

好比:

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

float类型：Float.floatToIntBits(f)

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

依此类推...

总结

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

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

覆盖equals方法以后必定要覆盖hashCode方法。

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