//鏈表存放  for (int binCount = 0; ; ++binCount) {      if ((e = p.next) == null) {          //鏈表尾部插入，p的next判斷是否為空          p.next = newNode(hash, key, value, null);          //當鏈表的長度大於等於樹化閥值，並且hash桶的長度大於等於MIN_TREEIFY_CAPACITY，鏈錶轉化為紅黑樹  //                        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;  }

//數組擴容  public Node<K,V>[] resize() {      Node<K,V>[] oldTab = table;      int oldCap = (oldTab == null) ? 0 : oldTab.length;      int oldThr = threshold;      int newCap, newThr = 0;      //如果舊hash桶不為空      if (oldCap > 0) {          ////超過hash桶的最大長度，將閥值設為最大值          if (oldCap >= MAXIMUM_CAPACITY) {              threshold = Integer.MAX_VALUE;              return oldTab;          }          //新的hash桶的長度2被擴容沒有超過最大長度，將新容量閥值擴容為以前的2倍          //擴大一倍之後，小於最大值，並且大於最小值          else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                  oldCap >= DEFAULT_INITIAL_CAPACITY)              //左移1位，也就是擴大2倍              newThr = oldThr << 1;      }      else if (oldThr > 0) //如果舊的容量為空，判斷閾值是否大於0，如果是那麼就把容量設置為當前閾值          newCap = oldThr;      else {               // zero initial threshold signifies using defaults          newCap = DEFAULT_INITIAL_CAPACITY;          newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);      }        //如果閾值還是0,重新計算閾值      if (newThr == 0) {          //當HashMap的數據大小>=容量*載入因子時，HashMap會將容量擴容          float ft = (float)newCap * loadFactor;          //如果容量還沒超MAXIMUM_CAPACITY的loadFactor時候，那麼就返回ft，否則就是回饋int的最大值          newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                  (int)ft : Integer.MAX_VALUE);      }      //hash桶的閾值      threshold = newThr;      //初始化hash桶      @SuppressWarnings({"rawtypes","unchecked"})      Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];      table = newTab;        if (oldTab != null) {          //遍歷舊數組          for (int j = 0; j < oldCap; ++j) {              Node<K,V> e;              //如果舊的hash桶不為空，需要將舊的hash表裡的鍵值對重新映射到新的hash桶中              if ((e = oldTab[j]) != null) {                  oldTab[j] = null;                  //只有一個節點，通過索引位置直接映射                  if (e.next == null)                      newTab[e.hash & (newCap - 1)] = e;  //取余                      //如果是紅黑樹，需要進行樹拆分然後映射  //                    else if (e instanceof TreeNode)  //                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);                  else { // preserve order                      //如果是多個節點的鏈表，將原鏈表拆分為兩個鏈表，兩個鏈表的索引位置，一個為原索引，一個為原索引加上舊Hash桶長度的偏移量                      Node<K,V> loHead = null, loTail = null;                      Node<K,V> hiHead = null, hiTail = null;                      Node<K,V> next;                      do {                          next = e.next;  //                            在遍歷原hash桶時的一個鏈表時，因為擴容後長度為原hash表的2倍，假設把擴容後的hash表分為兩半，分為低位和高位，  //                            如果能把原鏈表的鍵值對， 一半放在低位，一半放在高位，這樣的索引效率是最高的                          //這裡的方式是e.hash & oldCap，                          //經過rehash之後，元素的位置要麼是在原位置，要麼是在原位置再移動2次冪的位置。對應的就是下方的resize的注釋                          //為什麼是移動2次冪呢？？注意我們計算位置的時候是hash&(length - 1) 那麼如果length * 2 相當於左移了一位                          //也就是截取的就高了一位，如果高了一位的那個二進位正好為1，那麼結果也相當於加了2倍                          //hash & (length * 2 - 1) = length & hash + (length - 1) & hash                          if ((e.hash & oldCap) == 0) {                              //如果這個為0，那麼就放到lotail鏈表                              if (loTail == null)                                  loHead = e;                              else                                  loTail.next = e;                              loTail = e;                          }                          else {                              //如果length & hash 不為0，說明擴容之後位置不一樣了                              if (hiTail == null)                                  hiHead = e;                              else                                  hiTail.next = e;                              hiTail = e;                          }                      } while ((e = next) != null);                      if (loTail != null) {                          loTail.next = null;                          //而這個loTail鏈表就放在原來的位置上                          newTab[j] = loHead;                      }                      if (hiTail != null) {                          hiTail.next = null;                          //因為擴容了2倍，那麼新位置就可以是原來的位置，右移一倍原始容量的大小                          newTab[j + oldCap] = hiHead;                      }                  }              }          }      }      return newTab;  }

final Node<K,V> getNode(int hash, Object key) {      Node<K,V>[] tab; Node<K,V> first, e; int n; K k;      //注意這一步中(n - 1) & hash 的值 等同於 hash(k)%table.length      if ((tab = table) != null && (n = tab.length) > 0 &&              //這裡是計算相當於是取余的索引位置(n - 1) & hash 等價於hash % n              //而且由於hashmap中的length再tableSizeFor的時候，就把長度設置為2的n次冪了，那麼n-1之後的值，就是最高位全都是0，下面位數全是1              //這個也就是取hash的低位的值              (first = tab[(n - 1) & hash]) != null) {          if (first.hash == hash && // always check first node                  ((k = first.key) == key || (key != null && key.equals(k))))              return first;          if ((e = first.next) != null) {              //暫時不考慮紅黑樹  //                if (first instanceof TreeNode)  //                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);              do {                  if (e.hash == hash &&                          ((k = e.key) == key || (key != null && key.equals(k))))                      return e;              } while ((e = e.next) != null);          }      }      return null;  }