6.HashMap源码解析

1.数据结构

如上图所示，HashMap底层的数据结构主要是数组 + 链表 + 红黑树。其中当链表的长度大于等于8时，链表会转化成红黑树，当红黑树的大小小于等于6时，红黑树会转化成链表。图中左边竖着的是HashMap的数组结构，数组的元素可以是单个Node，也可以是链表或红黑树，比如数组下标索引为2的位置就是一个链表，下标索引为9的位置对应的是红黑树。
源码

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
	//初始容量为16
	static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
	
	//最大容量
	static final int MAXIMUM_CAPACITY = 1 << 30;
	
	//负载因子默认值
	static final float DEFAULT_LOAD_FACTOR = 0.75f;
	
	//桶上的链表长度大于等于8时，链表转化成红黑树
	static final int TREEIFY_THRESHOLD = 8;
	
	//桶上的红黑树大小小于等于6时，红黑树转化成链表
	static final int UNTREEIFY_THRESHOLD = 6;
	
	//当数组容量大于64时，链表才会转化成红黑树
	static final int MIN_TREEIFY_CAPACITY = 64;
	
	//记录迭代过程中HashMap结构是否发生变化，如果有变化，迭代时会fail-fast
	transient int modCount;
	
	//HashMap的实际大小，可能不准(因为当拿到这个值的时候，可能该值又发生了变化)
	transient int size;
	
	//存放数据的数组
	transient Node<K,V>[] table;
	
	/**
     * 扩容的门槛，有两种情况
     * 如果初始化时，给定数组大小的话，通过tableSizeFor方法计算，数组大小永远接近于2的幂次方，例如给定初始化大小19，实际上初始化大小为32，为2的5次方
     * 如果是通过resize方法进行扩容，大小 = 数组容量 * 0.75
     */
	int threshold;
	
	//链表的节点
	static class Node<K,V> implements Map.Entry<K,V> {
	
	//红黑树的节点
	static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {......}
}

源码解析

1. HashMap允许null值，不同于HashTable，是线程不安全的。
2. 影响因子(load factor)默认值是0.75，是均衡了时间和空间损耗计算出来的值，较高的值会减少空间开销(扩容减少，数组大小增长速度变慢)，但增加了查找成本(hash冲突增加，链表长度变长)，不扩容的条件是数组容量 > 需要的数组大小 / load factor。
3. 如果HashMap需要储存很多数据时，建议HashMap的初始容量一开始就设置的足够大，这样可以防止扩容时所带来的性能影响。
4. HashMap是非线程安全的，可以在外部加锁，或者通过Collections的synchronizedMap方法来实现线程安全，synchronizedMap的实现是在每个方法上加上了synchronized锁。
5. 在迭代过程中，如果HashMap的结构被修改，会快速失败。

2.新增
新增key和value的源码如下所示。
源码

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
	//入参hash为通过hash算法计算出来的值
	//入参onlyIfAbsent为boolean类型，默认为false，表示即使key已经存在了，仍然会用新值覆盖原来的值，
	final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
	    //n表示数组的长度，i为数组索引下标，p为i位置的节点
	    Node<K,V> [] tab; Node<K,V> p; 
	    int n, i;
	    //如果数组为空，使用resize方法初始化
	    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);
	    //如果当前索引位置有值，即常说的hash冲突
	    else {
	        //e为当前节点的临时变量
	        Node<K,V> e; 
	        K k;
	        //如果key的hash和值都相等，直接把当前下标位置的Node值赋值给临时变量
	        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) {
	                //e = p.next表示从头开始，遍历链表
	                //p.next == null表明p是链表的尾节点
	                if ((e = p.next) == null) {
	                    //把新节点放到链表的尾部 
	                    p.next = newNode(hash, key, value, null);
	                    //当链表的长度大于等于8时，链表转红黑树
	                    if (binCount >= TREEIFY_THRESHOLD - 1)
	                        treeifyBin(tab, hash);
	                    break;
	                }
	                //链表遍历过程中，发现有元素和新增的元素相等，结束循环
	                if (e.hash == hash &&
	                    ((k = e.key) == key || (key != null && key.equals(k))))
	                    break;
	                //更改循环的当前元素，使p在遍历过程中一直往后移动
	                p = e;
	            }
	        }
	        //e != null说明新节点的新增位置已经找到
	        if (e != null) {
	            V oldValue = e.value;
	            //当onlyIfAbsent为false时，才会覆盖原值 
	            if (!onlyIfAbsent || oldValue == null)
	                e.value = value;
	            afterNodeAccess(e);
	            //返回老值
	            return oldValue;
	        }
	    }
	    ++modCount;
	    //如果HashMap的实际大小大于扩容的门槛，开始扩容
	    if (++size > threshold)
	        resize();
	    afterNodeInsertion(evict);
	    return null;
	}
}

源码解析

1. 先判断空数组有无初始化，没有的话则进行初始化。
2. 如果通过key的hash能够直接找到值，跳转到6，否则跳转到3。
3. 如果hash冲突，两种解决方案，链表或红黑树。
4. 如果是链表，递归循环，把新元素追加到队尾。
5. 如果是红黑树，调用红黑树新增的方法。
6. 通过2、4、5将新元素追加成功后，再根据onlyIfAbsent判断是否需要覆盖。
7. 判断是否需要扩容，需要扩容则进行扩容，否则结束新增流程。

3.链表的新增
链表的新增比较简单，把当前节点追加到链表的尾部，和LinkedList的追加实现是一样的。当链表长度大于等于8时，此时的链表就会转化成红黑树，转化的方法是treeifyBin，此方法有一个判断，当链表长度大于等于8，并且整个数组大小大于64时，才会转成红黑树，当数组大小小于6 时，只会触发扩容，不会转化成红黑树。
面试的时候，通常会问为什么是8，是因为链表查询的时间复杂度是O(n)，红黑树的查询复杂度是O(log(n))。在链表数据不多的时候，使用链表进行遍历也比较快，只有当链表数据比较多的时候，才会转化成红黑树。但红黑树占用的空间是链表的2倍，考虑到转化时间和空间损耗，所以需要定义出转化的边界值。设计这个边界值的时候，参考了泊松分布概率函数，链表各个长度的命中概率如下所示。

* 0:    0.60653066
* 1:    0.30326533
* 2:    0.07581633
* 3:    0.01263606
* 4:    0.00157952
* 5:    0.00015795
* 6:    0.00001316
* 7:    0.00000094
* 8:    0.00000006

当链表的长度为8的时候，出现的概率是0.00000006，不到千万分之一，所以说正常情况下，链表的长度不可能到达8，而一旦到达8时，肯定是hash算法出了问题，所以在这种情况下，为了让HashMap仍然有较高的查询性能，所以让链表转化成红黑树。使用HashMap时，几乎不会碰到链表转化成红黑树的情况，毕竟概率只有千万分之一。

4.红黑树的新增
红黑树新增节点过程的源码如下所示。
源码

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
	//入参h为key的hash值
	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;
	        //p的hash值大于h，说明p在h的右边
	        if ((ph = p.hash) > h)
	            dir = -1;
	        //p的hash值小于 h，说明p在h的左边
	        else if (ph < h)
	            dir = 1;
	        //判断要放进去的key在当前树中是否已存在(通过equals来判断)
	        else if ((pk = p.key) == k || (k != null && k.equals(pk)))
	            return p;
	        //自定义的Comparable不能用hashcode比较，需要用compareTo
	        else if ((kc == null &&
	                  //得到key的Class类型，如果key没有实现Comparable就是null
	                  (kc = comparableClassFor(k)) == null) ||
	                  //当前节点pk和入参k不等
	                 (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;
	        //找到和当前hashcode值相近的节点(当前节点的左右子节点其中一个为空即可)
	        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;
				/**
				 * balanceInsertion对红黑树进行着色或旋转，以达到更高的查找效率，着色或旋转的几种场景如下
				 * 着色:新节点总是为红色。如果新节点的父亲是黑色，则不需要重新着色，如果父亲是红色，那么必须通过重新着色或者旋转的方法，再次达到红黑树的5个约束条件
				 * 旋转:父亲是红色，叔叔是黑色时，进行旋转
				 * 如果当前节点是父亲的右节点，则进行左旋
				 * 如果当前节点是父亲的左节点，则进行右旋
				 */
	            //moveRootToFront方法是把算出来的root放到根节点上
	            moveRootToFront(tab, balanceInsertion(root, x));
	            return null;
	        }
	    }
	}	
}

源码解析

1. 首先判断新增的节点在红黑树上是否已经存在，判断方法有两种，如果节点没有实现Comparable接口，使用equals进行判断，如果节点实现了Comparable接口，则使用compareTo进行判断。
2. 新增的节点如果已经在红黑树上，直接返回，不在的话，判断新增节点是在当前节点的左边还是右边，左边值小，右边值大。
3. 自旋递归第1步和第2步，直到当前节点的左边或者右边的节点为空时，停止自旋，当前节点即为新增节点的父节点。
4. 把新增节点放到当前节点的左边或右边为空的位置，并为当前节点建立父子节点关系。
5. 进行着色和旋转，流程结束。

5.查找
HashMap的查找主要分为两步，第一步是根据hash算法定位数组的索引位置，equals判断当前节点是否是需要寻找的key，是的话直接返回，否则继续第二步。第二步会判断当前节点有无next节点，有的话判断是链表类型，还是红黑树类型。分别走链表和红黑树不同类型的查找方法。链表查找的关键源码如下。

//采用自旋方式从链表中查找key
do {
    //如果当前节点hash等于key的hash，并且equals相等，当前节点即是要找的节点
    //当hash冲突时，通过equals方法来比较key是否相等
    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
        return e;
    //否则，把当前节点的下一个节点拿出来继续寻找
} while ((e = e.next) != null);