JDK1.8 HashMap实现原理与解析（部分）

前言

今天我们了解一下HashMap，关于HashMap，网上已有很多资料，这里我尝试以自己的理解、以尽可能简单且容易理解的方式重述一遍。表述不当的地方欢迎大家指正。

HashMap属性和JDK1.8新特性

结构

数组+链表（JDK1.8之前）

数组+（链表/红黑树）（JDK1.8新特性）

如上图

上面为数组 数组存储链表的头节点（浅绿）、红黑树的根节点（浅红）以及灰色的null

实际上，在数组达到需要扩容的阈值时，还是会有null。这是因为，为了避免哈希冲突，HashMap采用了拉链法，即把冲突的键值对放到相应数组位上形成一个链表，每多一次冲突，链表尾部就会新增一个键值对实体（JDK1.8中，当链表长度大于等于8时，链表将被转化为红黑树）。

基本属性

默认初始容量 DEFAULT_INITIAL_CAPACITY=16

如果没有指定初始容量，将使用此初始容量。

*这里的容量在初始化时与数组容量相等，然而在判断是否需要扩容时（包括取用Map的size()时），所取用的HashMap大小实际是链表和红黑树中所有的键值对实体（Entry）而不是数组中的非空元素。

负载因子 loadFactor =DEFAULT_LOAD_FACTOR=0.75（默认）

当数组新加入元素后size(红色字体提到的所有键值对总数)大于负载因子和容量的乘积（阈值，源码中称为threshold），则扩容（容量变为二倍）。

 static final int TREEIFY_THRESHOLD = 8;//数组位对应的数据结构变为树的阈值

 static final int UNTREEIFY_THRESHOLD = 6;//数组位对应的数据结构变回链表的阈值

如结构中所表达的，在对HashMap进行增删操作时，数组位置对应的数据结构是有可能会发生变化的。

知识补充

HashMap如何通过hash算法取到数组下标(或者说为什么HashMap的容量要是2的整数幂)

（n-1）&hash        //n为数组容量，hash为哈希值

由于HashMap规定，数组容量只能是2的整数幂，那么n-1的表示就很明确了——数值大小刚好是数组的最大下标，二进制表示是低位全部为1，高位全部为0，这样的数和32位的hash去与，显然就是保留了hash的低位作为数组下标，这样hash算法的随机性可以保证数组的任意位置都有可能被取到，同时也保证了不会发生数组越界。

如：hash  =  0b1011 1111 1111 0101 1101 0011 0011 1100

       n=16=0b 1 0000

       n-1=0b    0 1111

     hash&(n-1)=00000000000000000000000001100        (只保留了后四位）

HashMap的哈希算法

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

这是HashMap中计算hash的方法，可以注意到，非空情况下，返回的是（h=key.hashCode()) ^ (h >>> 16)。

为什么这样做呢？答案是：减少哈希碰撞。

hashCode的取值是在整个int范围内变化的，那么就会有类似这样一种哈希碰撞的情况：两个对象的hashCode低位完全相等，但是高位却相差很多，按照上面hash映射到数组的方法，这两个对象是极有可能映射到同一个数组下标的。要解决这个问题，就要让高位参与运算，检查两个二进制数的差异性，异或无非是最好用的方法，这个语句做的是这件事。

 

 

插入新键值对

 public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;//判断数组是否为空，为空则重新初始化
        if ((p = tab[i = (n - 1) & hash]) == null)//根据哈希值计算出数组下标
            tab[i] = newNode(hash, key, value, null);//如果位置为空则新建键值对节点
        else {//当前的位置不为空
            Node<K,V> e; K k;
            if (p.hash == hash &
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;//如果是同一个key，那么直接覆盖掉当前节点的Value，完成插入
            else if (p instanceof TreeNode)//是红黑树节点，交给树节点的插入方法处理
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {//是链表节点
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {//没找到需要的Key，新建
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&//找到了需要的Key，退出循环，后面的代码负责放入Value
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;//放入新的Value
                afterNodeAccess(e);
                return oldValue;//放回旧的Value
            }
        }
        ++modCount;
        if (++size > threshold)//超出阈值，扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }

 

扩容的问题

如上篇所表达的，当size大于阈值时，数组会进行扩容。所谓扩容，实际就是把原有结构中的所有结点数据转移到新的容量更大（2倍原始容量）的数组中。关于扩容的实现方法，网上的帖子很多很全，也写的很详细，这里就不再赘述。

主要介绍一下扩容中遇到的一个问题，以及如何解决。

扩容中数组容量变成了原来的2倍，而上面提到，数组下标的计算是（n-1）*hash，由此可推知以下问题：

 

那么如何重新分配节点呢？

首先我们肯定会想到哈希函数：重新hash()一下不就可以了吗？但事实并非这样，因为这个时候节点的指针会发生变化，所以重新hash()后得到的哈希值并不一定和原来一样，那么如果想拿原来的key来找value,几乎是不可能的，而不变的，就只有节点初始化时存入的hash常量（源码中它是final的）。

因此，我们只能利用节点对象中的hash常量来进行重新分配空间，保证用原来key的hash值还能拿到对应的节点

查看源码的resize()，发现了这样一句语法：

当需要转移该元素，进行这样的判断。实际上判断中的语句是取了多出来的那个hash最高位，如果最高位是0，那么loTail就是这个节点，hiTail则为空，否则相反，这两个变量又会参与下面的判断。

紧接着，下面的语句又进行了操作：

显然可以推出，对于最高位是0的情况，放到 j 的位置，而对于最高位是1的情况，放到 j + oldCap的位置。

为什么是 j +oldCap（原数组容量）呢？如下图所示：

可以看到，最后两个节点所放的位置分别对应上了他们的hash所对应的数组下标，问题解决。

 

 

以上是本篇文章全部内容，欢迎大家观摩指正。