JDK8 对 hash算法和寻址算法做了哪些优化？

Posted 2021-04-12 程序员大帝

点击蓝色“程序员大帝 ”关注我哟

加个“星标”，及时阅读最新技术文章

每日鸡汤，好喝

---

前言

接着上篇文章《》，咱们继续聊聊 HashMap 这个重要的数据结构。虽然它很简单，但是每一次读源码，我都有不同的体会，当然唯一不变的是对 Doug Lea 大神的崇拜。

在 JDK8 之后，对 HashMap 进行了重写，最显而易见的当然是引入了红黑树。由此而来，对它的哈希算法和寻址算法也做了一定的优化。

正文

寻址算法

在插入和查找数据的时候，我们会根据 key 得到它对应的 hash 值，然后再根据这个 hash 值进行一系列计算，得到元素在数组的下标位置，这个计算过程就是就是寻址算法。

 final Node<K,V> getNode(int hash, Object key) {
 Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&            (first = tab[(n - 1) & hash]) != null) {            if (first.hash == hash && // always check first node                ((k = first.key) == key || (key != null && key.equals(k)))) return first;
 if ((e = first.next) != null) {
                if (first instanceof TreeNode) return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {                    if (e.hash == hash &&                        ((k = e.key) == key || (key != null && key.equals(k))))                        return e;                } while ((e = e.next) != null);            } }        return null; }

其中最关键的是下面这一行，它展示了如何通过计算好的 hash 值来得到对应的哈希槽的位置：

first = tab[(n - 1) & hash])

大家第一个想法肯定是通过模运算来计算，因此引出了下面的问题

HashMap 中寻址算法为什么使用&（与运算），代替模运算？

我们知道了一个 key 的 hash 值，用这个hash值跟数组长度取模，就可以得到下标位置，其中 n 是数组的长度：

（n - 1) & hash

如果使用与运算，其实该算法的结果和模运算的结果是相同的。

但是，对于现代的处理器来说，除法和求余数（模运算）是最慢的动作。

根据数学公式：

a % b = （b-1） & a

 

当 b 是 2 的指数时，等式成立。大家应该记起来，HashMap 默认的长度一定是 2 的指数幂，所以这一个等式针对 HashMap 是永远成立的。通过与运算，提高了运算的效率。

哈希算法

static final int hash(Object key) {
     int h;      return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);}

看完源代码，第一次肯定会被其中的异或运算和右移运算搞蒙，为什么要异或呢？为什么要移位？而且移位 16？

我们分析一下：

首先，假设有一种情况，如果数组长度 n=16，那么根据寻址算法，也就是哈希值 和 15 这个数进行与运算

对象 A 的 hashCode 为 1000 0100 0111 0001 0000 0111 1000 0000

n-1=15                       0000 0000 0000 0000 0000 0000 0000 1111        

对象 B 的 hashCode 为 0111 0111 0011 1000 1010 0001 0100 0000

n-1=15                       0000 0000 0000 0000 0000 0000 0000 1111        

我们会发现 A、B 和 15 这个数进行与运后，得出来的结果都是 0， 这样的散列结果太让人失望了。很明显不是一个好的散列算法。

但是如果我们将 hashCode 值右移 16 位，然后再进行异或运算（如果两个数不同，结果为1，相同为0），这样的话，就能避免我们上面的情况的发生。

对象A hashCode：               1000 0100 0111 0001 0000 0111 1000 0000

对象A hashCode右移16位：  0000 0000 0000 0000 1000 0100 0111 0001

异或运算：                          1000 0100 0111 0001 1000 0011 1111 0001

n-1=15                                0000 0000 0000 0000 0000 0000 0000 1111  

与运算：                              0000 0000 0000 0000 0000 0000 0000 0001

对象B hashCode：               0111 0111 0011 1000 1010 0001 0100 0000

对象B hashCode右移16位： 0000 0000 0000 0000 0111 0111 0011 1000

异或运算：                          0111 0111 0011 1000 1101 0110 0100 1000

n-1=15                               0000 0000 0000 0000 0000 0000 0000 1111   

与运算：                             0000 0000 0000 0000 0000 0000 0000 1000

通过结果可以看出来，这样异或运算得到结果，再和 n-1 与运算，得到结果不同，避免了 hash 冲突。

文末福利

找工作的小伙伴可以后台联系我，拉你进秋招/内推/面试群，我也给大家整理了各大公司的内推通道、简历模板还有历年的笔试题，大家要好好准备哦。

还可以帮助大家免费修改简历、模拟面试哦~可能下期视频的主角就是你哦~

我是无忌，Stay Tuned！