HashMap插入数据执行流程分析

概要

JDK1.7中的HashMap底层实现为数组+链表，JDK1.7中的HashMap存在问题：多线程状态下内部数组扩容时有可能会导致死循环。所以，JDK1.8中对HashMap进行了重新实现，其底层实现为数组+链表+红黑树。提高了HashMap的性能。

HashMap源码解读

内部属性

• static final int DEFAULT_INITIAL_CAPACITY

  默认初始化容量，默认值16，要求改值必须为2的幂次方数。至于为何必须是2的幂次方数，简单来说就是为了提高map的key在放入数组时候的散列性，将在下文分析。

• static final int MAXIMUM_CAPACITY

  默认值为1<<30，数组最大容量。

• static final float DEFAULT_LOAD_FACTOR

  默认负载因子，默认值为0.75，数组会根据负载因子*当前容量决定是否需要扩容。

• static final int TREEIFY_THRESHOLD

  树形化阈值，默认值为8，当数组内链表长度超过当前值后，会考虑将其转换为红黑树结构以提升效率。当前阈值是决定是否转换为红黑树的条件之一。

• static final int UNTREEIFY_THRESHOLD

  反树形化阈值，默认为6，当红黑树节点少于当前值时候，会从红黑树转换为链表结构。

• static final int MIN_TREEIFY_CAPACITY

  最小树形化容量阈值，默认值64，当数组容量超过当前值，会考虑将数组中链表转换为红黑树结构，和TREEIFY_THRESHOLD共同判断是否需要转换为红黑树。

• transient Node<K,V>[] table

  HashMap中用于存储数据的数组

存储数据的执行流程

存储数据源码分析

map存储数据需要调用put方法，下面将从put方法切入

public V put(K key, V value) {
  	//调用putVal向数组中添加数据
    return putVal(hash(key), key, value, false, true);
}

put方法内部会调用putVal方法，以下是putVal执行流程

/**
	* hash: 待存入数据的key值的hash值
	* key： 待存入数据的key值
	* value： 待存入数据的value值
	* onlyIfAbsent： 如果key值相等，是否覆盖原有值
	* evict： 数组处于创建状态标识
	* V:返回值为当前key值的旧值，如果不存在就返回null
	**/
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属性为懒加载，所以首次调用put方法时将会调用resize方法创建table属性
        if ((tab = table) == null || (n = tab.length) == 0)
          //初始化table并得到当前数组长度
            n = (tab = resize()).length;
  			/**
  				*	p=tab[i=(n-1)&hash]用于获取数组中key将要放置的节点位置
	  			*	通过`(n-1)&hash`得到其下标，这也是为什么数组容量要求为2的幂次方的原因所在（当n为2的幂次方数时，n-1的二进制值得所有低位都为1，这样在和hash执行&运算时，使结果只根hash的值相关，提高了结果的分散性）。为了保证数组容量为2的幂次方数，内部也对用户传入的数组容量做了处理，见tableSizeFor方法。
  				*		
  				* 如果当前位置的节点为null，说明当前位置未曾放置对象，可直接创建节点对象，并放入数组
  				**/
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
          	//当前位置已经存在节点：
            Node<K,V> e; K k;
         	//根据当前key值计算出的位置存在节点且节点key和当前key相等，则把e变量指向已存在节点的引用，在最后修改并返回旧值
            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) {
                  //遍历链表，直到找到链表最后一个元素，将当前待存放的数据存入尾结点的next属性
                  //这里和JDK1.7中不同的是，JDK1.7中向链表中新增元素是头插法，而JDK1.8这里则是尾插法
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                      //链表中新增数据后，判断链表长度是否超过`TREEIFY_THRESHOLD`，调用`treeifyBin`内部判断是否转换为红黑树
                        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;
                }
            }
          //e不为空说明存在key值相同的元素，返回旧值
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
  			//根据整个map中键值对的个数，判断当前数组是否需要扩容
  			//size>threshold则需要扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

以下是HashMap中数组扩容的流程：

//内部数组扩容方法
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
  			//获取扩容前数组长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
  			//扩容前的扩容阈值
        int oldThr = threshold;
        int newCap, newThr = 0;
  		//如果旧数组容量大于0，说明数组已经初始化过了
        if (oldCap > 0) {
          	//如果扩容前的数组容量大于最大容量，已经没有扩容的余地了，返回旧表
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
          //如果扩容后容量依然在最大限制范围内，并且扩容前容量大于默认初始化容量，设置新的阈值为旧阈值的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
  			//数组容量为0，但是阈值存在，则将阈值设置为扩容目标大小
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
  			//按照默认大小初始化数组
        else {               // zero initial threshold signifies using default
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
  			//按照新的数组容量大小，创建新的数组newTab
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
  			//如果扩容前数组为null，说明是第一次懒加载初始化数组，直接返回创建好的newTab即可。
  			//否则则为数组扩容
        if (oldTab != null) {
          	//遍历旧表中每一个元素
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
              	//e指向扩容前table中各个元素的引用
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                  	//e.next==null说明当前位置链表只有一个元素，那么则根据e.hash&(newCap-1)重新计算在新表中的位置，并将e放到新表中
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                  //如果e是树节点，执行树节点拆分
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                  //e节点是长度大于1的链表
                    else { 
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                      //使用do{}while循环遍历链表中的每一个元素，根据(e.hash&oldCap)是否为0将链表拆分为2个链表
                        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);
                      //将loHead为头结点的链表放在新表中和扩容前下标相同的位置
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                      //将hiHead为头结点的链表放在[新表中和扩容前下标+扩容前数组长度]的位置
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

另外比较有意思的一个点是HashMap内部为了保证数组容量为2的幂次方数，会在tableSizeFor方法对外部传入的数组容量进行处理，使不论外部传的值是多少，总能得到一个2的幂次方数。

方法思路：主要利用的一个点就是任何一个2的幂次方数，其二进制的值只有一个二进制位为1，其余二进制位都为0。

static final int tableSizeFor(int cap) {
        int n = cap - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

总结

通过对HashMap源码的学习可知：

• HashMap在超过范围后会自动扩容，扩容会导致性能下降，所以在平时开发中尽可能的避免数组扩容，可以在创建HashMap中指定容量。
• HashMap的添加数据中没有同步措施，所以在多线程环境下会有线程安全问题，多线程情况下可使用ConcurrentHashMap。
• 默认的负载因子值为0.75，是官方通过试验得出的经验值，最好不要动。