HashMap 计算 Hash 值的扰动函数

2023-02-28

int out hash

计算过程以下代码叫做“扰动函数”复制//java8中的散列值优化函数staticfinalinthash(Objectkey){inth;return(key==null)?0:(h=key.hashCode())^(h>>>16);}1.2.3.4.5.理论上hash散列是一个i

计算过程

以下代码叫做 “扰动函数”

//java 8 中的散列值优化函数
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}1.
2.
3.
4.
5.

理论上 hash 散列是一个 int 值，如果直接拿出来作为下标访问 hashmap 的话，考虑到二进制 32 位，取值范围在-2147483648 ~ 2147483647。大概有 40 亿个 key ，只要哈希函数映射比较均匀松散，一般很难出现碰撞。

一个客观的问题：要存下 40 亿长度的数组，服务器内存是不能放下的。通常咱们 HashMap 的默认长度为 16 。所以这个 hashCode , (key.hashCode ) 是不能直接来使用的。使用之前先做对数组长度的与运算，得到的值才能用来访问数组下标。

代码如下：

// n = hashmap 的长度
p = tab[i = (n - 1) & hash])1.
2.

这里为什么要使用 n -1 ，来进行与运算，这里详单与是一个”低位掩码”, 以默认长度 16 为例子。和某个数进行与运算，结果的大小是 < 16 的。如下所示：

10000000 00100000 00001001
&   00000000 00000000 00001111
------------------------------
    00000000 00000000 00001001  // 高位全部归 0, 只保留后四位1.
2.
3.
4.

这个时候会有一个问题，如果本身的散列值分布松散，只要是取后面几位的话，碰撞也会非常严重。还有如果散列本身做得不好的话，分布上成等差数列的漏洞，可能出现最后几位出现规律性的重复。

这个时候“扰动函数”的价值就体现出来了。如下所示：

在 hash 函数中有这样的一段代码：(h = key.hashCode()) ^ (h >>> 16) 右位移 16 位，正好是32bit 的一半，与自己的高半区做成异或，就是为了混合原始的哈希码的高位和低位，以此来加大低位的随机性。并且混合后的低位掺杂了高位的部分特征，这样高位的信息变相保存下来。其实按照开发经验来说绝大多数情况使用的时候 HashMap 的长度不会超过 1000，所以提升低位的随机性可以提升可以减少 hash 冲突，提升程序性能。

如果感兴趣的小伙伴可以浏览下一下 Peter Lawlay 的专栏《An introduction to optimising a hashing strategy》的一个实验：他随机选取了 352 个字符串，在散列值完全没有冲突的前提下，对低位做掩码，取数组下标。

结果显示，当 hashmap 的数组长度为 512 的时候，也就是采用低位掩码取低 9 位的时候，在没有扰动函数的情况下，发生了 103 次碰撞，接近 30%。而在使用扰动函数之后只有 92 次碰撞。碰撞减少了将近10%。说明扰动函数确实有功效的。

但是明显 Java 8 觉得扰动做一次就够用了，做 4 次的话，可能边际效用也不大，为了效率考虑就改成了一次。

代码演示‍

import java.lang.reflect.Field;
import java.util.HashMap;

/**
 * HashMap 计算 hashKey
 * <p>
 * 演示：扰动函数
 *
 * @see HashMap#hash(Object)
 */
public class HashKeyTest {

    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        HashMap<String, String> map = new HashMap<>();
        String k = "王羲之";
        String v = "大书法家";
        map.put(k, v);

        Field field = map.getClass().getDeclaredField("table");
        field.setAccessible(Boolean.TRUE);
        Object[] nodes = (Object[]) field.get(map);

        int h = k.hashCode();
        System.out.println("  h=" + h);
        System.out.println();
        // 调用 hashCode 结果
        System.out.println("  h=hashCode()    " + num0x(h) + "  调用 hashCode");
        // 无符号右移 16
        System.out.println("  h>>>16          " + num0x(h >>> 16));
        System.out.println("--------------------------------------------------");
        // 计算 hash
        System.out.println("  hash=h^(h>>>16) " + num0x(h ^ (h >>> 16)) + "  计算 hash");
        System.out.println("--------------------------------------------------");
        // 计算下标
        System.out.println("  (n-1)&hash      " + num0x(15 & (h ^ (h >>> 16))) + "  计算下标");
        System.out.println();
        int idx = (15 & (h ^ (h >>> 16)));
        // 输出下标
        System.out.println("  下标: " + idx);
        // 在下标中去获取数据
        System.out.println("  查询结果:" + nodes[idx]);
    }

    /**
     * 输入 int 转换为 二进制字符串
     *
     * @param num 数字
     * @return 二进制字符串
     */
    static String num0x(int num) {
        String num0x = "";
        for (int i = 31; i >= 0; i--) {
            num0x += (num & 1 << i) == 0 ? "0" : "1";
        }
        return num0x;
    }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.