Map的實現類HashMap的各種方法源碼解析

1. map.put 方法

       // map.put 方法 
        public V put(K key, V value) {// hash(key) 得到key的hash值 將數據儘量均勻分佈
           return putVal(hash(key), key, value, false, true);// put 方法實現
       }
       
       // putVal 方法
       final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                      boolean evict) {
           Node<K,V>[] tab; Node<K,V> p; int n, i;
           // 判斷 tab 與 table 是否等於null 
           if ((tab = table) == null || (n = tab.length) == 0)
               n = (tab = resize()).length;// 執行初始化操作 初始大小爲 16
           if ((p = tab[i = (n - 1) & hash]) == null)// 判斷 p 是否爲null
               tab[i] = newNode(hash, key, value, null);// 如果爲空 從根據hash計算的index開始    
                                                        // put 
           else {
               Node<K,V> e; K k;
               // 判斷p的hash 與newPut的hash 是否相等 並且 key 不是 null 
               if (p.hash == hash && 
                   ((k = p.key) == key || (key != null && key.equals(k))))
                   e = p;// 成立 則將 p 賦值與 e
               else if (p instanceof TreeNode)// 判斷 p 是否是屬於 treeNode 類
                   // 成立則執行 紅黑樹 putTreeVal 方法,鏈表put長度 >= 8 執行此方法
                   e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
               else {
                   // 普通的鏈表存儲方法
                   for (int binCount = 0; ; ++binCount) {
                       if ((e = p.next) == null) {// 判斷 p 是否是鏈表存儲數據的last                                                                     
                                                  // p.next = null 則 p 是鏈表的末尾Node
                           p.next = newNode(hash, key, value, null);// 定義p.next 爲 newNode
                           if (binCount >= TREEIFY_THRESHOLD - 1) //循環是從0開始的 所以>= 7 
                                                               //之後的Node 調用的是紅黑樹方法
                               treeifyBin(tab, hash);
                           break;
                       }
                       // 判斷 e.hash 是否與 hash 相等 相等說明是 e 節點的put 跳出循環 需要執行 
                       // 覆蓋方法
                       if (e.hash == hash &&
                           ((k = e.key) == key || (key != null && key.equals(k))))
                           break;
                       p = e;// 條件都不成立 繼續循環
                   }
               }
               if (e != null) { // 執行原存在 key.value 的覆蓋方法
                   V oldValue = e.value;
                   if (!onlyIfAbsent || oldValue == null)
                       e.value = value;
                   afterNodeAccess(e); // 用於LinkedHashMap 查其他地方的說明 待驗證
                   return oldValue; 返回oldValue 
               }
           }
           ++modCount;// 操作++
           if (++size > threshold)// size ++ 大於擴容閥值 執行擴容方法
               resize();// 擴容方法
           afterNodeInsertion(evict); // 用於LinkedHashMap 查其他地方的說明 待驗證
           return null;
       }
   
       // resize 方法 執行擴容
       final Node<K,V>[] resize() {
           Node<K,V>[] oldTab = table;// 定義oldTab 
           // 定義oldCap 是 0 還是 oldTab.length
           int oldCap = (oldTab == null) ? 0 : oldTab.length;
           int oldThr = threshold;// 定義 oldThr 一般爲0 或者是 oldTab.length * 0.75
           int newCap, newThr = 0;// 定義 newCap,newThr = 0
           if (oldCap > 0) {// 判斷oldCap 是否 > 0
               if (oldCap >= MAXIMUM_CAPACITY) {// 判斷oldCap 是否大於MAXIMUM_CAPACITY
                   threshold = Integer.MAX_VALUE;// 成立 定義 threshold = Integer.MAX_VALUE
                   return oldTab;// 返回oldTab 
               }
               // 定義 newCap = oldCap * 2 並且判斷 NewCap < MAXIMUM_CAPACITY && oldCap >= 16
               else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                        oldCap >= DEFAULT_INITIAL_CAPACITY)
                   newThr = oldThr << 1; // 成立 定義 newThr 爲 oldThr * 2
           }
           else if (oldThr > 0) // oldCap = 0 && oldThr > 0 
               newCap = oldThr;// 定義 newCap = oldThr
           else {
               // oldCap = 0 && oldThr = 0
               newCap = DEFAULT_INITIAL_CAPACITY;//設置 newCap 爲 默認大小 16
               // 設定 newThr = 0.75 * 16
               newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
           }
           if (newThr == 0) {// 判斷newThr == 0 
               // 從新計算 newThr 爲 newCap < MAXIMUM_CAPACITY  並且 new閥值 <             
               // MAXIMUM_CAPACITY 返回 new閥值 或者 Integer.Max_value
               float ft = (float)newCap * loadFactor;// newCap * 0.75(負載係數) 
               newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                         (int)ft : Integer.MAX_VALUE);
           }
           threshold = newThr;// 將new閥值 賦值爲Threshold 
           @SuppressWarnings({"rawtypes","unchecked"})
               Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//執行 newTab 的操作
           table = newTab;// 從新定義 table
           if (oldTab != null) {// 判斷oldTab != null
               for (int j = 0; j < oldCap; ++j) {// 循環執行node的遷移
                   Node<K,V> e;
                   // 定義 e 判斷 e != null
                   if ((e = oldTab[j]) != null) {
                       oldTab[j] = null;// 設置oldTab[j] = null 方便回收資源
                       if (e.next == null)// 判斷 e 的下一個Node 是否是null 
                           //  通過hash值計算新表的索引位置, 直接將該節點放在該位置
                           newTab[e.hash & (newCap - 1)] = e;
                       else if (e instanceof TreeNode)// 判斷是否是 TreeNode 
                           // 執行TreeNode 的 split 方法 [方法複雜 隨後補充]
                           ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                       else { // preserve order
                           Node<K,V> loHead = null, loTail = null;//存儲跟原索引位置相同的節點
                           Node<K,V> hiHead = null, hiTail = null;//存儲索引位置爲:原索引    
                                                                  // +oldCap的節點
                           Node<K,V> next;
                           do {// do{}while()循環
                               // 定義 nextNode 
                               next = e.next;
                               if ((e.hash & oldCap) == 0) {
                                   if (loTail == null)// 判斷 loTail == null 代表是第一個Node
                                       loHead = e;
                                   else
                                       loTail.next = e;// 將e設置爲loTail的下一個Node
                                   loTail = e;// 從新定義loTail 
                               }
                               else {
                                   if (hiTail == null)// 判斷 hiTail == null 代表是第一個Node
                                       hiHead = e;
                                   else
                                       hiTail.next = e;// 將e設置爲hiTail的下一個Node
                                   hiTail = e;// 從新定義 hiTail 
                               }
                           } while ((e = next) != null);
                           // 找到末尾Node  從末尾開始賦值newTab
                           if (loTail != null) {//定義末尾的Node 
                               loTail.next = null;
                               newTab[j] = loHead;// 原索引位置
                           }
                           if (hiTail != null) {//定義末尾的Node 
                               hiTail.next = null;
                               newTab[j + oldCap] = hiHead;//原索引位置 + oldCap 
                           }
                       }
                   }
               }
           }
           return newTab;// 返回newTab 沒有想到 hashMap.put 方法 如此複雜 
       }

    

2. map.get 方法

       // map.get 方法
       public V get(Object key) {
           Node<K,V> e;
           // 定義 e 根據key.hashCode 找到Node, 判斷是否是 null, 返回null 或者 e.value
           return (e = getNode(hash(key), key)) == null ? null : e.value;
       }
       
       // getNode 方法
       final Node<K,V> getNode(int hash, Object key) {
           Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
           // 定義tab 定義n 定義first 並且都不爲null
           if ((tab = table) != null && (n = tab.length) > 0 &&
               (first = tab[(n - 1) & hash]) != null) {
               if (first.hash == hash && // 判斷是否是firstNode
                   ((k = first.key) == key || (key != null && key.equals(k))))
                   return first;// 條件成立返回first
               // 定義e 是first的下一個 並且不是 null
               if ((e = first.next) != null) {
                   if (first instanceof TreeNode)// 判斷first 是否屬於 TreeNode 類
                       // 執行TreeNode的getTreeNode方法 [隨後補上]
                       return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                   do {// do{}while()循環查找 
                       if (e.hash == hash &&
                           ((k = e.key) == key || (key != null && key.equals(k))))
                           return e;// 一直循環下一個 匹配返回
                   } while ((e = e.next) != null);
               }
           }
           return null;// 無匹配數據 返回null
       }

    

3. map.remove 方法

       // map.remove 方法
       public V remove(Object key) {
           Node<K,V> e;
           return (e = removeNode(hash(key), key, null, false, true)) == null ?
               null : e.value;
       }
       
       // removeNode 方法 
       final Node<K,V> removeNode(int hash, Object key, Object value,
                                  boolean matchValue, boolean movable) {
           Node<K,V>[] tab; Node<K,V> p; int n, index;
           // 定義 tab,n,p是根據hash值計算出index的Node 都不爲null
           if ((tab = table) != null && (n = tab.length) > 0 &&
               (p = tab[index = (n - 1) & hash]) != null) {
               Node<K,V> node = null, e; K k; V v;
               //判斷需要remove的Node是否是根據hash值計算出的 p 
               if (p.hash == hash &&
                   ((k = p.key) == key || (key != null && key.equals(k))))
                   node = p;// 條件成立(成立的原因一般是Node != null 但是 key == null) 定義Node
               //定義 e 爲p 判斷 p的下一個Node  不是 null
               else if ((e = p.next) != null) {
                   if (p instanceof TreeNode)// 判斷p是否屬於TreeNode類
                       //執行TreeNode 的 getTreeNode 方法[隨後補充]
                       node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                   else {
                       do {//do{}while()循環查詢
                           if (e.hash == hash &&
                               ((k = e.key) == key ||
                                (key != null && key.equals(k)))) {
                               node = e;//條件成功 定義node 並結束
                               break;
                           }
                           p = e;//繼續循環下一個
                       } while ((e = e.next) != null);
                   }
               }
               // 判斷 node != null matchValue:false 定義v (目前感覺只要走到這裏 這裏一定是成立            
               // 的)
               if (node != null && (!matchValue || (v = node.value) == value ||
                                    (value != null && value.equals(v)))) {
                   if (node instanceof TreeNode)// 判斷node屬於TreeNode類
                       // 執行 TreeNode 的 removeTreeNode 方法 [隨後補充]
                       ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                   else if (node == p)// 直接將node的下一個賦值給tab[index]
                       tab[index] = node.next;//從新定義了tab[index] oldNode 被覆蓋
                   else
                       // 此處經過循環 p.next = node 從新定義p.next = node.next
                       // 直接 remove node節點
                       p.next = node.next;//將 node的下一個node 賦值給p的下一個 鏈表操作
                   ++modCount;//操作++
                   --size;//size --
                   afterNodeRemoval(node);
                   return node;//返回node
               }
           }
           return null;//返回null
       }

    

4. map.clear 方法

       // map.clear 方法
       public void clear() {
           Node<K,V>[] tab;
           modCount++;//操作++
           if ((tab = table) != null && size > 0) {
               size = 0;//從新定義size 爲 0 
               for (int i = 0; i < tab.length; ++i)
                   tab[i] = null;//循環操作 定義每一個node爲null
           }
       }

    

5. map.hash 方法

       // hash(key) 方法 比較特殊 需要慢慢理解
           static final int hash(Object key) {
           int h;
           return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
       }