HashMap方法源码分析

 1 final Node<K,V>[] resize() {
 2     // 获取原有table
 3     Node<K,V>[] oldTab = table;
 4     int oldCap = (oldTab == null) ? 0 : oldTab.length;
 5     int oldThr = threshold;
 6     // 新容量、新阈值
 7     int newCap, newThr = 0;
 8     if (oldCap > 0) {
 9         // 如果原有容量超过设定最大容量，则不进行扩容
10         if (oldCap >= MAXIMUM_CAPACITY) {
11             threshold = Integer.MAX_VALUE;
12             return oldTab;
13         }
14         // 如果原容量翻倍后不超过最大容量且原容量超过16，则进行翻倍扩容
15         else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
16                  oldCap >= DEFAULT_INITIAL_CAPACITY)
17             newThr = oldThr << 1; // double threshold
18     }
19     else if (oldThr > 0) // 使用阈值初始化容量，对应的是初始化hashmap带了容量cpacity参数。
20         newCap = oldThr;
21     else {               // zero initial threshold signifies using defaults
22         // 原容量和阈值都<=0,则用默认值初始化,默认容量16，负载因子0.75，阈值12，对应的是hashmap没带参数初始化。
23         newCap = DEFAULT_INITIAL_CAPACITY;
24         newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
25     }
26     if (newThr == 0) {
27         // 如果新阈值为0则赋值为新容量*负载因子(默认是0.75)
28         float ft = (float)newCap * loadFactor;
29         newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
30                   (int)ft : Integer.MAX_VALUE);
31     }
32     threshold = newThr;// 更新阈值
33     // 基于新容量重新实例化一个node数组
34     @SuppressWarnings({"rawtypes","unchecked"})
35         Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
36     table = newTab;// 更新数组
37     if (oldTab != null) {
38         // 遍历数组的每个节点元素
39         for (int j = 0; j < oldCap; ++j) {
40             Node<K,V> e;
41             // 如果节点不为空
42             if ((e = oldTab[j]) != null) {
43                 oldTab[j] = null;// 将原数组节点指向空
44                 // case1：节点只有一个元素，直接根据hash值计算新位置
45                 if (e.next == null)
46                     newTab[e.hash & (newCap - 1)] = e;
47                 // case2：节点为红黑树节点，进行红黑树的复制操作    
48                 else if (e instanceof TreeNode)
49                     ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
50                 // case3：节点为链表节点，进行链表的赋值操作    
51                 else { // preserve order
52                     // 低位Node链表头节点和尾节点
53                     Node<K,V> loHead = null, loTail = null;
54                     // 高位Node链表头节点和尾节点
55                     Node<K,V> hiHead = null, hiTail = null;
56                     Node<K,V> next;
57                     // 遍历原链表，拆分成低位链表和高位链表
58                     do {
59                         next = e.next;
60                         // 如果是在原位置，则加入低位链表
61                         if ((e.hash & oldCap) == 0) {
62                             if (loTail == null)
63                                 loHead = e;
64                             else
65                                 loTail.next = e;
66                             loTail = e;
67                         }
68                         else {
69                             // 如果不在原位置，加入高位链表
70                             if (hiTail == null)
71                                 hiHead = e;
72                             else
73                                 hiTail.next = e;
74                             hiTail = e;
75                         }
76                     } while ((e = next) != null);
77                     // 如果低位链表不为空
78                     if (loTail != null) {
79                         // 尾部节点赋空并将头部节点放入数组指定位置
80                         loTail.next = null;
81                         newTab[j] = loHead;
82                     }
83                     // 如果高位链表不为空
84                     if (hiTail != null) {
85                         // 尾部节点赋空并将头部节点放入数组指定位置
86                         hiTail.next = null;
87                         newTab[j + oldCap] = hiHead;
88                     }
89                 }
90             }
91         }
92     }
93     return newTab;
94 }