1. //初始化容量 16
    2. static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
    3. //负载因子
    4. static final float DEFAULT_LOAD_FACTOR = 0.75f;
    5. //链表长度达到8成，变成红黑树
    6. static final int TREEIFY_THRESHOLD = 8
    7. //节点数组  
    8. transient Node<K,V>[] table;
    9. //默认无参构造
    10. public HashMap() {
    11.      this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    12. }
    13. //指定初始容量
    14. public HashMap(int initialCapacity) {
    15.      this(initialCapacity, DEFAULT_LOAD_FACTOR);
    16. }
    18.  final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    19.         Node<K,V>[] tab; 
    20.          Node<K,V> p; 
    21.          int n, i;
    22.          //如果node数组等于null或者长度位0，则进行初始化扩容
    23.         if ((tab = table) == null || (n = tab.length) == 0)
    24.             //扩容代码 初始容量16
    25.             n = (tab = resize()).length;
    26.          //如果哈希后，对应数组的node节点为null，则直接赋值
    27.         if ((p = tab[i = (n - 1) & hash]) == null)
    28.             tab[i] = newNode(hash, key, value, null);
    29.         else {
    30.             Node<K,V> e; K k;
    31.             //如果健的值以及hash等于链表中的第一个键值对节点时，则将e指向该键值对
    32.             if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))){
    33.                  e = p;
    34.             //如果对应的节点为树类型，则调用红黑树的插入方法
    35.             }else if (p instanceof TreeNode){
    36.                  e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
    37.             }else {
    38.                 //对链表进行遍历
    39.                 for (int binCount = 0; ; ++binCount) {
    40.                     if ((e = p.next) == null) {
    41.                         //如果链表中不包含要插入的键值对节点时，则将该节点写入到链表的最后
    42.                         p.next = newNode(hash, key, value, null);
    43.                         //如果链表的长度大于等于7，则转换成红黑树
    44.                         if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
    45.                             treeifyBin(tab, hash);
    46.                         break;
    47.                     }
    48.                     if (e.hash == hash &&
    49.                         ((k = e.key) == key || (key != null && key.equals(k))))
    50.                         break;
    51.                     p = e;
    52.                 }
    53.             }
    54.             if (e != null) { // existing mapping for key
    55.                 V oldValue = e.value;
    56.                 if (!onlyIfAbsent || oldValue == null)
    57.                     e.value = value;
    58.                 afterNodeAccess(e);
    59.                 return oldValue;
    60.             }
    61.         }
    62.         ++modCount;
    63.          //集合长度超过阈值时，进行扩容，
    64.         if (++size > threshold)
    65.             resize();
    66.         afterNodeInsertion(evict);
    67.         return null;
    68.     }
    70. final Node<K,V>[] resize() {
    71.         //将node数组赋值给oldTab
    72.         Node<K,V>[] oldTab = table;
    73.         //三元运算，oldTab等于null的话，oldCap=0，否则等于oldTab.length
    74.         int oldCap = (oldTab == null) ? 0 : oldTab.length;
    75.         //扩容的阈值
    76.         int oldThr = threshold;
    77.         int newCap, newThr = 0;
    78.         if (oldCap > 0) {
    79.             //table容量最大值，不在扩容
    80.             if (oldCap >= MAXIMUM_CAPACITY) {
    81.                 threshold = Integer.MAX_VALUE;
    82.                 return oldTab;
    83.              //2倍扩容
    84.             } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
    85.                      oldCap >= DEFAULT_INITIAL_CAPACITY){
    86.                  // double threshold
    87.                 newThr = oldThr << 1;
    88.             }
    89.         }else if (oldThr > 0){
    90.             // initial capacity was placed in threshold
    91.             newCap = oldThr;
    92.         } else {
    93.              //如果oldCap等于0, 则初始容量位16
    94.             newCap = DEFAULT_INITIAL_CAPACITY;
    95.             //阈值位16*0.75 = 12
    96.             newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    97.         }
    99.         if (newThr == 0) {
    100.             float ft = (float)newCap * loadFactor;
    101.             newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
    102.                       (int)ft : Integer.MAX_VALUE);
    103.         }
    104.         //扩容后需要rehash，再分配
    105.         threshold = newThr;
    106.         @SuppressWarnings({"rawtypes","unchecked"})
    107.         Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    108.         table = newTab;
    109.         if (oldTab != null) {
    110.             for (int j = 0; j < oldCap; ++j) {
    111.                 Node<K,V> e;
    112.                 if ((e = oldTab[j]) != null) {
    113.                     oldTab[j] = null;
    114.                     if (e.next == null)
    115.                         newTab[e.hash & (newCap - 1)] = e;
    116.                     else if (e instanceof TreeNode)
    117.                         ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
    118.                     else { // preserve order
    119.                         Node<K,V> loHead = null, loTail = null;
    120.                         Node<K,V> hiHead = null, hiTail = null;
    121.                         Node<K,V> next;
    122.                         do {
    123.                             next = e.next;
    124.                             if ((e.hash & oldCap) == 0) {
    125.                                 if (loTail == null)
    126.                                     loHead = e;
    127.                                 else
    128.                                     loTail.next = e;
    129.                                 loTail = e;
    130.                             }
    131.                             else {
    132.                                 if (hiTail == null)
    133.                                     hiHead = e;
    134.                                 else
    135.                                     hiTail.next = e;
    136.                                 hiTail = e;
    137.                             }
    138.                         } while ((e = next) != null);
    139.                         if (loTail != null) {
    140.                             loTail.next = null;
    141.                             newTab[j] = loHead;
    142.                         }
    143.                         if (hiTail != null) {
    144.                             hiTail.next = null;
    145.                             newTab[j + oldCap] = hiHead;
    146.                         }
    147.                     }
    148.                 }
    149.             }
    150.         }
    151.         return newTab;
    152.     }

    https://segmentfault.com/a/1190000012926722