随笔：深入理解HashMap——put和get方法的源码分析

    hashmap是一种特殊的数据结构，在jdk1.7以及之前，采用拉链法（数组+链表）实现哈希表，在jdk1.8的时候，加入了红黑树的数据结构，提高了散列值冲突情况下的查询效率。

直接看源代码（参考jdk1.8）：

1.hashmap是如何存储和查询数据的：
    我们都知道要通过put(K key, V value)方法向hashmap中存储键值对，下面我们就从put方法展开，对存储过程进行详细分析：

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

可以看到，put方法非常简单，仅仅是通过return一个putVal的方法调用，在我们分析putVal方法之前，我们注意到还有一个hash(K key)方法，那么我们先来分析这个方法：

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

hash方法是hashmap的核心方法，我们看到这个方法用来计算键key的散列值，是hashmap的散列函数。计算方法非常简单，一个三元操作符就可以完成。key如果为null，那么散列值为0；否则调用key的java.lang.Object.hashCode()函数获得对象key本身的哈希值，将这个哈希值无符号右移16位（转化为二进制，向右移动16位，高位补0），最后将两个数进行异或处理（二进制数相同位，值相同为0，不同为1）作为key真正的散列值返回。

理解了hash()函数之后，我们接下来看这个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;
        //table是hashMap的散列桶（就是数组）
        //如果在插入此条数据之前哈希表为空，或者哈希表的桶长度为0，那么对哈希表进行扩容处理（resize()方法），n为桶长度。
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //i=(n-1)&hash是根据key对象的散列值，计算该key应该存放的散列桶数组下标（这个key存放在哪个桶中），与此同时，&运算也保证了i的数值不会超过桶长度。
        //如果对应的桶不存在Node节点（Node节点用于存储key和value），那么通过newNode()方法就新建一个Node节点。p为连接桶的链表表头节点。
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //如果对应的桶已经存在Node节点(已经在这个桶存储了Node)
        else {
            Node<K,V> e; K k;
            //如果要插入的hash值和表头p的哈希值相同且两个键值对的键相同（是同一对象或者内容相同），那么e=表头p。
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果p节点是一个红黑树节点类型，那么直接将新的键值对插入到红黑树中
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //如果p节点是一个普通的Node节点
            else {
            //否则遍历链表，通过binCount记录链表长度
                for (int binCount = 0; ; ++binCount) {
                    //在链表末尾新建一个Node
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        //如果链表长度>=8，那么通过treeifyBin()方法将这个链表转化为一个红黑树（提高查询效率，O(N)变为O(logN)），然后break跳出循环。
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //遇到相同的键，break。
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    //p=e，准备进行下一次for循环。
                    p = e;
                }
            }
            //如果e不为空，证明存在相同的键，检查新旧value值是否相同，并查看是否允许更新旧值或者旧值为null，进行value的更新并返回旧值。
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //modCount用来实现迭代器的快速失败，添加一个键值对之后要增加size，并通过和阀值threshold对比来决定是否resize()扩容
        ++modCount;
        if (++size > threshold)
            resize();
        //afterNodeInsertion(boolean evict)是一个空方法体，可以继承HashMap类并覆盖这个方法来决定插入操作完成后应该干什么。
        afterNodeInsertion(evict);
        return null;
    }

putVal方法又牵扯出许多其他的变量和方法，变量分别是：Node，table，TreeNode, TREEIFY_THRESHOLD, threshold方法有：resize(), newNode(), putTreeVal(), treeifyBin()。我们来一一分析这些内容。

    先分析Node，static class Node<K,V> implements Map.Entry<K,V> {...}，我们知道这个类是一个链表的节点类，里面存放了(final K)key,(V)value,(final int)hash,(Node<K,V>)next这四种数据就可以。

    再分析table,table在hashmap中的定义为：transient Node<K,V>[] table;可见table是一个Node数组，transient意味着不能序列化。table是hashmap的散列桶，数组里为null或者存放着链表表头或者红黑树根节点。table的大小一定是2的整数次幂，原因后面会讲到。

    TreeNode，也是用来存储key和value的数据结构，只不过从链表形式转化为树节点。

    TREEIFY_THRESHOLD定义了每个散列桶结构从链表转换到红黑树的临界值。当链表长度超过这个值得时候，就会从链表转化到红黑树。

    threshold，中文意思是阀值，其值为table长度*负载因子（loadFactor,默认值0.75f）。它和size共同决定了是否需要对hashmap进行扩容。一旦size>=threshold，那么就会调用resize()方法扩容。

    然后是方法的分析，我们只终点讲解resize()方法，探究hashmap究竟是如何扩容的：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//将table存入oldTab中
        int oldCap = (oldTab == null) ? 0 : oldTab.length;//oldCap存放oldTab的数组长度
        int oldThr = threshold;//oldThr存放oldTab的负载因子threshold
        int newCap, newThr = 0;
        //如果旧table长度不是零
        if (oldCap > 0) {
        	//如果oldTab（之前的table）的长度已经达到规定的最大容量（2的30次幂），那么无法对这个hashmap进行扩容处理，直接返回之前的table保持原样。
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //将oldCap左移1位（即*2）并传递给newCap，如果新值<最大容量且旧值>=初始容量（1<<4=16）,那么将newThr也左移1位(*2)。
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //如果oldCap==0且oldThr>0
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        //如果oldCap==oldThr==0，进行初始化
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;//16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//16*0.75f
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        //重设threshold
        threshold = newThr;
        //到此为止，我们知道了大多数情况下：newCap=2*oldCap,newThr=2*oldThr
        @SuppressWarnings({"rawtypes","unchecked"})
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//新的散列表容量是原来的2倍
        table = newTab;
        //将原来的散列表的内容转移到新的散列表中
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                //如果旧散列表桶中存在Node节点（即已经存放了键值对）
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //如果是末节点
                    if (e.next == null)
                    	//将这个Node转移到新散列表中
                        newTab[e.hash & (newCap - 1)] = e;
                    //如果Node是红黑树的根节点
                    else if (e instanceof TreeNode)
                    	//将根节点转移到新散列表中
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //如果Node是链表的表头节点，且后面还链接有其他节点
                    //通过do-while转移这些节点
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

以上就是对resize()方法的详细分析。

接下来我们来分析get(Object Value)方法，有了put方法的铺垫，我们再看get方法会简单很多，因为get方法并不会涉及到hashmap结构的变化：

public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
	//根据hash值和key值来查找value
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        //table不为空，且table长度不为0，且哈希值对应的散列桶不为空（即桶上已经存储了数据）
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
        	//如果头结点的hash等于对应Node的hash且key值相同（防止散列值冲突的情况）
            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;
    }

最后，我们来讨论一个细节问题：

hashmap的大小为什么是2的次幂（即table.length为什么是2的次幂）：因为这样能使Node均匀分布在散列桶中，参考分布函数：table[(table.length-1) & hash]，关键是&运算，2的次幂保证了进行-1操作之后的结果一定的单数，即二进制码的最后一位一定是XXXX XXX1的形式（X可以是0，也可以是1），这样就保证了&运算的结果有可能是单数，有可能是双数。如果不是2的次幂，有可能出现-1操作之后的二进制码是XXXX XXX0的情况，这样进行&运算的时候，导致最终结果一定是偶数，即键值对总会被分布到偶数桶中，导致哈希表利用率低下。