HashMap底层源码分析（一）———put实现原理

今天自学了HashMap的put的源码实现 ，来记录下，第一次理解HashMap，可能写的乱，如有不对，大家评论一起讨论

1、源码中的重要常量

DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16

/**
* The default initial capacity - MUST be a power of two.
* 默认初始容量-必须是2的次幂。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

DEFAULT_LOAD_FACTOR：HashMap的默认负载因子

/**
 * The load factor used when none specified in constructor.
 * 构造函数中未指定时，使用的负载因子
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;

table：存储元素的数组，总是2的n次幂

transient Node<K,V>[] table;

TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树

static final int TREEIFY_THRESHOLD = 8;

MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量。

（当桶中Node的 数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行 resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4 倍。）

static final int MIN_TREEIFY_CAPACITY = 64;

2、Put方法

put方法，首次put时，进入resize()方法，创建数组

Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
    n = (tab = resize()).length;

resize方法

else {               // zero initial threshold signifies using defaults
    newCap = DEFAULT_INITIAL_CAPACITY; //HashMap的默认容量，16
    newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//计算扩容的临界值 12
}
...
threshold = newThr;//扩容的临界值赋值给threshold，    扩容的临界值 = HashMap默认的容量 * 默认的负载因子
...
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];	//创建长度为16的Node[]数组
table = newTab;//将数组赋值给table

判断步骤

1. 首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法以后，得到在Node数组中的存放位置
2. 如果此位置上的数据为空，此时的key1-value1添加成功

if ((p = tab[i = (n - 1) & hash]) == null)
    tab[i] = newNode(hash, key, value, null);

3. 如果此位置上的数据不为空，（意味着此位置上存在一个或多个数据（以链表形式存在）），比较key1和已经存在的一个或多个数据的哈希值

• 如果Key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功
• 如果key1的哈希值和已经存在的某一数据（key2-value2）的哈希值相同，继续比较：调用key1所在类的equals(key2)
  • 如果equals()返回false：此时key1-value1添加成功
  • 如果equals()返回true：使用value1替换value2

else {
    Node<K,V> e; K k;
    
    //比较hash值、equals()方法，如果都相等，说明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);
    
    //在比较hash值、equals()方法不成立
    else {
        //遍历当前位置可能存在的链表
        for (int binCount = 0; ; ++binCount) {
            
            //如果当前位置没有链表，直接添加到p的next
            if ((e = p.next) == null) {
                p.next = newNode(hash, key, value, null);
                
                //如果遍历的下标大于等于7时（即链表长度大于8，插入第九个节点时），进入treeifyBin方法
                if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                    treeifyBin(tab, hash);
                break;
            }
            
            //如果当前有链表，继续比较hash值、equals()方法
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
                break;
            
            //并把p.next重新赋值给p，再次遍历链表下一个元素
            p = e;
        }
    }
    
    //只要key存在，都会走此方法，进行值的替换
    if (e != null) { // existing mapping for key
        V oldValue = e.value;
        if (!onlyIfAbsent || oldValue == null)
            e.value = value;
        afterNodeAccess(e);
        return oldValue;
    }
}

4. 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8，并且当前数组的长度 > 64时，此时此索引位置上的所有数据改为使用红黑树存储

   final void treeifyBin(Node<K,V>[] tab, int hash) {
       int n, index; Node<K,V> e;
       
       //如果hash表为空或者hash表长度小于64，进行扩容，而不进行转换红黑树
       if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
           resize();
       
       //如果以链表形式存在的数据个数 > 8，并且当前数组的长度 > 64时，转换成红黑树
       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);
       }
   }