HashMap底层原理的故事

阅读源码的时候，就会像在拔一棵树，带着各种根茎的大树，需要一点点的把根茎梳理清楚。那种抽丝剥茧的快乐（是快乐么？），难以言喻

而且仅仅只是HashMap的源码，就已经让人头秃了。

本篇博文的版本是基于java8的。

1.首先快乐的建立了一下测试代码

public class HashMapTest {
    public static void main(String[] args) {
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("1", "1");
    }
}

然后断点进入到new HashMap()方法。

原来就是一行赋值操作负载因子而已。就是把一个变量赋值成某一个静态变量。但其实这里面大有讲究。讲究到我得专门再写一篇文章。好的。 请移步到下面那篇文档读一读概念。

  HashMap底层原理的故事-负载因子和初始容量

好的。我们明白了他设置了一个负载因子，备用。

2.接下来呢，进入put方法

那么put方法又做了啥惊人的操作，好的，第一个参数，hash( key) 方法。

        那么我们都知道Object类是所有java类的父类，那么Object类中的hashCode方法，是个什么鬼呢，他的底层实现方法是什么呢，怎么计算hashCode的呢。那我们接着看。HashMap底层原理的故事-Object的hashCode

1.计算hashCode的时候，为什么要无符号右移16位后做异或运算

根据上面的说明我们做一个简单演练

将h无符号右移16为相当于将高区16位移动到了低区的16位，再与原hashcode做异或运算，可以将高低位二进制特征混合起来

从上文可知高区的16位与原hashcode相比没有发生变化，低区的16位发生了变化

我们可知通过上面(h = key.hashCode()) ^ (h >>> 16)进行运算可以把高区与低区的二进制特征混合到低区，那么为什么要这么做呢？

我们都知道重新计算出的新哈希值在后面将会参与hashmap中数组槽位的计算，计算公式：(n - 1) & hash，假如这时数组槽位有16个，则槽位计算如下：

     

仔细观察上文不难发现，高区的16位很有可能会被数组槽位数的二进制码锁屏蔽，如果我们不做刚才移位异或运算，那么在计算槽位时将丢失高区特征

也许你可能会说，即使丢失了高区特征不同hashcode也可以计算出不同的槽位来，但是细想当两个哈希码很接近时，那么这高区的一点点差异就可能导致一次哈希碰撞，所以这也是将性能做到极致的一种体现

2.使用异或运算的原因

 异或运算能更好的保留各部分的特征，如果采用&运算计算出来的值会向1靠拢，采用|运算计算出来的值会向0靠拢

     

3.为什么槽位数必须使用2^n

如果槽位数是2的N次方，那么可以通过位运算e.hash & (newCap - 1)来计算，也就是说a % (2^n) 等价于 a & (2^n - 1)  ，位运算的运算效率高于算术运算，原因是算术运算还是会被转化为位运算

 

不懂 槽位是啥，没关系，带着疑问往下看，慢慢就明白了。

 

2.接下来，跟踪的是putVal方法

先解释一下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)
            n = (tab = resize()).length; //resize()里面干了啥，咱们移步到这里resize()方法详解   最终n=16, tab=长度为16的数组new Node[16]
        if ((p = tab[i = (n - 1) & hash]) == null) // 来了，根据key的hash值对16取余，然后看下这个key值落在哪个槽位里。这个最终结果i=1,p=null；这就是槽位的概念的产生。以及为什么槽位非得要2的N次方，因为只有这样a % (2^n) 等价于 a & (2^n - 1)。然后看下这个槽位是不是空的。
            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;
            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) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            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;// 全局变量modCount，变动次数加1,最终值为1
        if (++size > threshold)//这个意思是啥呢。全局变量size从0变成1， threshold之前的resize()之后他现在是12，参考resize()方法详解 他最终会把全局变量threshold=12， 1<12,当然不扩容。  这里就有了个重要结论：当hashMap添加完元素后，如果发现size值>threshold (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY   HashMap底层原理的故事-负载因子和初始容量)时，他就会扩容。扩容多少呢。我们下面讲哈。
            resize();
        afterNodeInsertion(evict);
        return null;
    }

第一次put结束后，全局变量的最终态。

threshold	12
table	长度为16的数组new Node[16] ,  Node[1]=newNode("1".hash, "1", "1", null)
size	1
modCount	1

 

put第二个元素的流程（跟第一个元素在同一个槽位上）

 

我们第一次put ：  hashMap.put("1", "1");

于是我们进行第二次put： 通过计算我们得知 如果key="12"，他会跟key="1"放在同一个槽位上。

所以我们的测试代码为：

HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("1", "1");
        hashMap.put("12", "12");

并且我们现在分析第二个元素的流程,还是令人熟悉的putVal方法，还是熟悉的味道接着分析。

 

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);//这次就不一样了。咱们的全局变量table是有值的，它是长度为16的数组new Node[16] ,  Node[1]=newNode("1".hash, "1", "1", null)
        n = (tab = resize()).length;
    if ((p = tab[i = (n - 1) & hash]) == null) // 这下一经计算，槽位是同一个i=1。因为之前i=1已经放了一个key="1"的元素了，p=（key=“1”的node）所以这个判断是false；
        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)))) //判断下是不是put了key值相同的元素，决定是否要覆盖原有值，当然，这里不是哈。这里就有了个重要结论：判断key值重复的方法其实是key的equals方法
            e = p;
        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) {
                    p.next = newNode(hash, key, value, null); 就是把key=“1”的节点的next指向key=“12”的节点
                    if (binCount >= TREEIFY_THRESHOLD - 1) // TREEIFY_THRESHOLD=8看下不够8
                        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;  //全局变量+1=2
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict); 这个是干啥呢hashMap里面是啥都没干哈。不用看了。。
    return null;
}

 

 

put第三-七个元素的流程（跟第一二个元素在同一个槽位上）

HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("1", "1");
        hashMap.put("12", "12");
        hashMap.put("23", "23");

 核心 代码就一句p = e;  不停的变换指针找到tab[1]上面的所有链表的最末端，然后挂上去。直到---第8个元素

put第八个元素的流程（跟前7个元素在同一个槽位上）

当同一个槽位上的链表长度达到8的时候，

终于进入到了令人振奋的环节。转变为红黑树 什么是红黑树？之后我再开个章节写下

treeifyBin(tab, hash);

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) // 16小于64，还不够格，接着给我扩容去
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}