《Effective Java》中推荐的hashCode算法

在我们刚开始学习Java的时候就被教导，在编写类的时候，如果覆盖了Object的equals方法，那么必须要覆盖hashCode方法，并且如果两个对象用equals方法比较返回true，那么这两个对象hashCode返回的值也必须是相等的，并且对于同一个对象，equals方法需要比较的属性值没有被修改，那么每次调用hashCode返回的值应该是一致的。

hashCode主要是用于散列集合，通过对象hashCode返回值来与散列中的对象进行匹配，通过hashCode来查找散列中对象的效率为O(1)，如果多个对象具有相同的hashCode，那么散列数据结构在同一个hashCode位置处的元素为一个链表，需要通过遍历链表中的对象，并调用equals来查找元素。这也是为什么要求如果对象通过equals比较返回true,那么其hashCode也必定一致的原因。

为对象提供一个高效的hashCode算法是一个很困难的事情。理想的hashCode算法除了达到本文最开始提到的要求之外，还应该是为不同的对象产生不相同的hashCode值，这样在操作散列的时候就完全可以达到O(1)的查找效率，而不必去遍历链表。假设散列中的所有元素的hashCode值都相同，那么在散列中查找一个元素的效率就变成了O(N),这同链表没有了任何的区别。

这种理想的hashCode算法，如果是为具体业务的对象去设计应该不是很难，比如很多的数据库映射对象都存在一个整形的id属性，这个id属性往往在整个系统中是唯一的，那么hashCode在重写的时候返回这个id的值就可以了，equals比较的时候也是去比较id的值，并且对象在从数据库初始化之后是不可变的，这样就完全达到了理想的情况。这些对象保存在散列中，查找效率会是完全的O(1)，不需要遍历任何链表。

 

Google首席Java架构师Joshua Bloch在他的著作《Effective Java》中提出了一种简单通用的hashCode算法

1. 初始化一个整形变量，为此变量赋予一个非零的常数值，比如int result = 17;

2. 选取equals方法中用于比较的所有域，然后针对每个域的属性进行计算：

  (1) 如果是boolean值，则计算f ? 1:0

  (2) 如果是byte\char\short\int,则计算(int)f

  (3) 如果是long值，则计算(int)(f ^ (f >>> 32))

  (4) 如果是float值，则计算Float.floatToIntBits(f)

  (5) 如果是double值，则计算Double.doubleToLongBits(f)，然后返回的结果是long,再用规则(3)去处理long,得到int

  (6) 如果是对象应用，如果equals方法中采取递归调用的比较方式，那么hashCode中同样采取递归调用hashCode的方式。　　否则需要为这个域计算一个范式，比如当这个域的值为null的时候，那么hashCode 值为0

  (7) 如果是数组，那么需要为每个元素当做单独的域来处理。如果你使用的是1.5及以上版本的JDK，那么没必要自己去　　　　重新遍历一遍数组，java.util.Arrays.hashCode方法包含了8种基本类型数组和引用数组的hashCode计算，算法同上，

　　java.util.Arrays.hashCode(long[])的具体实现:

public static int hashCode(long a[]) { 
        if (a == null) 
            return 0; 
  
        int result = 1; 
        for (long element : a) { 
            int elementHash = (int)(element ^ (element >>> 32)); 
            result = 31 * result + elementHash; 
        } 
  
        return result; 
} 

 

Arrays.hashCode(...)只会计算一维数组元素的hashCOde,如果是多维数组，那么需要递归进行hashCode的计算，那么就需要使用Arrays.deepHashCode(Object[])方法。

 

3. 最后，要如同上面的代码，把每个域的散列码合并到result当中：result = 31 * result + elementHash;

4. 测试，hashCode方法是否符合文章开头说的基本原则，这些基本原则虽然不能保证性能，但是可以保证不出错。

 

这个算法存在这么几个问题需要探讨:

1. 为什么初始值要使用非0的整数?这个的目的主要是为了减少hash冲突，考虑这么个场景，如果初始值为0,并且计算hash值的前几个域hash值计算都为0，那么这几个域就会被忽略掉，但是初始值不为0,这些域就不会被忽略掉，示例代码:

import java.io.Serializable; 
 public class Test implements Serializable { 
  
    private static final long serialVersionUID = 1L; 
  
    private final int[] array; 
  
    public Test(int... a) { 
        array = a; 
    } 
  
    @Override
    public int hashCode() { 
        int result = 0; //注意，此处初始值为0         for (int element : array) { 
            result = 31 * result + element; 
        } 
        return result; 
    } 
  
    public static void main(String[] args) { 
        Test t = new Test(0, 0, 0, 0); 
        Test t2 = new Test(0, 0, 0); 
        System.out.println(t.hashCode()); 
        System.out.println(t2.hashCode()); 
    } 
  
} 

 

如果hashCode中result的初始值为0，那么对象t和对象t2的hashCode值都会为0，尽管这两个对象不同。但如果result的值为17,那么计算hashCode的时候就不会忽略这些为0的值，最后的结果t1是15699857，t2是506447

 

2. 为什么每次需要使用乘法去操作result?　主要是为了使散列值依赖于域的顺序，还是上面的那个例子，Test t = new Test(1, 0)跟Test t2 = new Test(0, 1), t和t2的最终hashCode返回值是不一样的。

 

3. 为什么是31? 31是个神奇的数字，因为任何数n * 31就可以被JVM优化为 (n << 5) -n,移位和减法的操作效率要比乘法的操作效率高的多。