HashMap原理解析

HashMap是工作中使用频率最高的用于键值对处理的数据类型。随着JDK版本的更新，JDK1.8对HashMap底层的实现进行了优化，引入红黑树的数据结构和扩容的优化等。本文基于JDK1.8，深入探讨HashMap的结构实现和原理。

本来想一篇写完，结果越写越多，先发上去再抽空编辑

我们从一段代码入手，开始解析HashMap的实现原理

	Map<String, Demo> map = new HashMap<>();
	map.put("demo1", new Demo("test1", "11"));
	map.put("demo2", new Demo("test2", "12"));
	map.put("demo3", new Demo("test3", "13"));
	map.put("demo4", new Demo("test4", "14"));
	
	Demo d = map.get("demo1");

当我们看到new关键字，说明内存中出现一个HashMap对象，HashMap构造器源码如下，这里初始化了一个0.75的负载因子

	 public HashMap() {
	     this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
	 }

接着来看一下put的源码，这里先对key进行hash计算，接着调用putVal方法

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

HashMap的hash方法，这里调用Object类的hashCode方法后，右移16位，与自身进行异或运算，这个操作称为扰动算法，目的是有效减少计算后的hash值低位冲突概率

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

进入到putVal方法后，为了便于理解，我调整了一下代码结构(注释)，在放入第一个元素之前，先调用了resize方法

	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;
 //     注释    
 //     Node<K,V>[] tab = talbe;
 //     int n = tab.length;
 //     if(tab == null || n == 0) {
 //     	tab = resize();
 //     	n = tab.length;
 //     }
 //		... 其余代码省略
    }

进入resize，这里只保留关键代码，可以看出当我们放入第一个元素时，即底层数组还是null，系统会初始化一个长度为16的Node数组，省略的代码是HashMap自动扩容及扩容后属性Copy使用，这里不赘述

	final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {...} else if (oldThr > 0) {...}
        else {     
        	// 初始化长度          
            newCap = DEFAULT_INITIAL_CAPACITY; // 16
            // 扩容长度
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 0.75 * 16
        }
        if (newThr == 0) {...}
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {...}
        return newTab;
    }

接着回到putVal，通过上一步，我们知道第一段代码初始化了一个长度为16的Node数组，继续改造代码(注释2)，第一步通过数组长度-1与传入的hash值做按位与运算赋值给i，得到的值必定是0至15之间的值，&的特性是：当两位都为1，结果为1。(前面扰动算法的优势就体现在这里)接着判断下标为i的位置为空后，调用newNode构造方法，并将值放在下标i的位置，方法结束时，更新修改次数及判断是否需要扩容(resize方法中自动扩容部分)，

	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;
 //     注释1  
 //     Node<K,V>[] tab = resize(); 
 //     int n = tab.length;

 //     源代码
		if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
 //     注释2          
 //		int i = (n - 1) & hash;
 //		Node<K,V> p = tab[i];
 //		if(p == null) {
 //			tab[i] = newNode(hash, key, value, null);
 //		}
 //		...
 		++modCount;
        if (++size > threshold)
            resize();
    }

到这里一次常规的put操作就完成了，下面分析一下出现hash碰撞，即计算出的hash值低位相同时，计算出的数组下标相同时，HashMap的处理方式，HashMap的作者实在太严谨了，严格遵守了变量在第一次使用的时候才初始化的规则，这里偷个懒就不更改结构了，直接在代码中进行注释分析。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
 //     注释1  省略
 //     注释2  省略        
 		else {
            Node<K,V> e; K k;
            // 当key的hash、引用、内容完全一致时，使用新对象覆盖旧对象，HashMap的key不能重复逻辑就是在这里控制的
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 出现hash碰撞后，当前数组元素类型为TreeNode时，是HashMap转换为红黑树后的数据结构，这个在下面细说
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            	// 这里binCount实际是个计数器，用来统计当前下标中，链表元素个数，超过8将当前链表转为红黑树结构
                for (int binCount = 0; ; ++binCount) {
                    // 每轮循环 首先令e指向链表下一个元素
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 判断binCount超过8后，调用treeifyBin方法，先跳过
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 这里处理hash碰撞情况下，HashMap的key不重复逻辑
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    // 下轮循环中的值取链表下一个节点 e = p.next
                    p = e;
                }
            }
            // 这里调用LinkedHashMap类中afterNodeAccess实现方法，向链表中插入数据先跳过
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
    }

接着看出现hash碰撞后，且元素数量超过8，HashMap的红黑树结构putTreeVal方法，putTreeVal是HashMap内部类TreeNode中的一个方法

		/**
         * map:  当前操作的HashMap对象
         * tab:  当前操作的HashMap中的Node数组
         * h:    key调用Object.hashCode后的值
         * k:    key
         * v:    value
         */
		final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab, int h, K k, V v) {
            Class<?> kc = null;
            boolean searched = false;
            TreeNode<K,V> root = (parent != null) ? root() : this;
            for (TreeNode<K,V> p = root;;) {
                int dir, ph; K pk;
                if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                else if ((pk = p.key) == k || (k != null && k.equals(pk)))
                    return p;
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0) {
                    if (!searched) {
                        TreeNode<K,V> q, ch;
                        searched = true;
                        if (((ch = p.left) != null &&
                             (q = ch.find(h, k, kc)) != null) ||
                            ((ch = p.right) != null &&
                             (q = ch.find(h, k, kc)) != null))
                            return q;
                    }
                    dir = tieBreakOrder(k, pk);
                }

                TreeNode<K,V> xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    Node<K,V> xpn = xp.next;
                    TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    xp.next = x;
                    x.parent = x.prev = xp;
                    if (xpn != null)
                        ((TreeNode<K,V>)xpn).prev = x;
                    moveRootToFront(tab, balanceInsertion(root, x));
                    return null;
                }
            }
        }

接着进入LinkedHashMap类中afterNodeAccess方法

	void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }