HashMap底层原理

在我们实际的项目中，HashMap这个集合类经常被用到，可是就是这么一个常用的集合类，却往往成了咱们面试中的绊脚石,即便你是个初级程序员，也常会让你谈谈HashMap的底层原理，今天咱们就来扒一扒这个HashMap的庐山真面目。

一、HashMap的特点

• 元素以键值对的方式存储，并且允许使用null作为键值;
• key不允许重复，因此只能有一个键为null;
• HashMap不能保证放入元素的顺序，它是无序的;
• HashMap是线程不安全的;

二、HashMap数据结构

JDK1.8之前，数据结构为：数组+列表

JDK1.8及之后，数据结构为：数组+列表+红黑树

为什么JDK1.8会引入红黑树数据结构呢？

我们来详细看下JDK1.8 HashMap的put和get方法就秒懂了。

HashMap内部有一个属性

transient Node<K,V>[] table;
static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
}

这个属性是一个Node数组，Node是一个链表的数据结构，所以整个就是数据+链表的数据结构。

put方法：

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)
      //关键点1
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null)//关键点2
        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))))//关键点3
            e = p;
        else if (p instanceof TreeNode)//关键点4
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {//关键点5
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    if (binCount >= TREEIFY_THRESHOLD - 1) // 关键点6
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash &&
                    ((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;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
       //关键点7
        resize();
    afterNodeInsertion(evict);
    return null;
}

如上代码中表示了几个关键位置，下面针对关键位置进行说明：

关键点1：

首次put时，调用resize方法创建table数组，默认Node<K,V>数组长度为16，因子为0.75*16（即超过该长度后，自动扩容数组，扩容后的数组长度等于原长度的2倍，而且长度只能是2的N次方）；

关键点2：

通过“(数组长度-1)&hash”得到下标值，这里引出两个问题：

A.为什么不是使用“数组长度%hash”得到数组下标呢？

这个是基于计算机本身的特性，因为&运算性能比取模的性能更高，并且存在数学恒等式：n%hash=(n-1)&hash。

B.为什么数组的长度必须是2的N次方？

如果数组长度不是2的N次方会出现什么结果。我们假设数组长度为10，按照上述(数组长度-1)&hash计算方法，计算过程如下：(10-1) & hash,转换成二进制后：1001&hash，根据&符号的特点，所有与0做&号运算的结果都为0，也就是通过1001&hash最终计算的结果只能是X00X，在明确点，计算结果只能是：0000/0001/1000/1001，既然如此，那有6个数组位永远都是空闲的，所以数组的长度只能是2的N次方。

C.如果多个线程同时进入执行到该代码块，并且计算的下标值是一样的，则会出现数据丢失。

关键点3：

如果对应的key等于传入的key，则表示就是自己，后续直接e.value=value将老的值替换成新值。

关键点4：

如果是红黑树节点，则添加到树中。

关键点5：

挨个找数组下标对应的链表，直到找到最后一个节点（尾插法），找到尾节点后，将新的节点设置为尾节点的子节点；这里需要注意，多线程的情况下，会出现数据丢失。

在jdk1.8之前，因为采用的是头插法，在扩容时当两个线程同时检测到hashmap需要扩容，在同时扩容的时候有可能会造成链表的循环，主要原因就是，采用头插法，新链表与旧链表的顺序是反的，具体感兴趣的朋友可以上网百度下，再次不在累述。
关键点6：

如果链表的长度超过8，则转换为红黑树数据结构。
关键点7：

如果元素的个数大于扩容因子数，则调用resize开始扩容，扩容时需要将数组中原有的数据重新计算下标位置进行转移。
 

Get方法：

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)
              //关键点1
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                //关键点2
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

以上是get方法代码，以上我们可以看出，首先是根据key的hash值，得到所在的数组下标位置，然后进一步从链表或红黑树查询，具体包括两个关键点：

 

关键点1：

如果为红黑树节点，则根据树形规则查找，会调用如下find方法，因为红黑树是一个二叉树，这里比较节点的hash值和要找的hash值，如果则节点值大于待查找的hash值，则从左边节点树找，否则从右边节点树找。

红黑树特点：

• 红黑树根节点必须为黑色;
• 红黑树每个叶子节点都要是黑色的空节点，也就是说，叶子节点不存储数据;
• 在红黑树中任何相邻的节点都不能同时为红色，也就是说，红色节点是被黑色节点隔开的;
• 红黑树中每个节点，从该节点到达其可达叶子节点的所有路径，都要包含相同数目的黑色节点;

 

final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
    TreeNode<K,V> p = this;
    do {
        int ph, dir; K pk;
        TreeNode<K,V> pl = p.left, pr = p.right, q;
        if ((ph = p.hash) > h)//判断点
            p = pl;
        else if (ph < h)
            p = pr;
        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
            return p;
        else if (pl == null)
            p = pr;
        else if (pr == null)
            p = pl;
        else if ((kc != null ||
                  (kc = comparableClassFor(k)) != null) &&
                 (dir = compareComparables(kc, k, pk)) != 0)
            p = (dir < 0) ? pl : pr;
        else if ((q = pr.find(h, k, kc)) != null)
            return q;
        else
            p = pl;
    } while (p != null);
    return null;
}

 

关键点2：

如果是链表，则while循环挨个往后找，直到找到，这里是时间复杂度为O(n)。

以上是HashMap的核心内容，其他还有诸多细节，朋友们可以调试进入代码一探究竟。