Jav8 HashMap-putVal() 方法分析

最新推荐文章于 2025-06-16 11:52:19 发布

原创

最新推荐文章于 2025-06-16 11:52:19 发布 · 8.3k 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#Java

带中文注释的源码解析

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; 
 
          // 如果存储元素的table为空，则进行必要字段的初始化 
 
          if ((tab = table) == null || (n = tab.length) == 0) 
 
              n = (tab = resize()).length;    // 获取长度（16） 
 
          // 如果根据hash值获取的结点为空，则新建一个结点 
 
          if ((p = tab[i = (n - 1) & hash]) == null)      // 此处 & 代替了 % （除法散列法进行散列） 
 
              tab[i] = newNode(hash, key, value, null); 
 
          // 这里的p结点是根据hash值算出来对应在数组中的元素 
 
          else { 
    
              Node<K,V> e; K k; 
 
              // 如果新插入的结点和table中p结点的hash值，key值相同的话 
 
              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); 
 
              else { 
    
                  for (int binCount = 0; ; ++binCount) { 
    
                      // 代表这个单链表只有一个头部结点，则直接新建一个结点即可 
 
                      if ((e = p.next) == null) { 
    
                          p.next = newNode(hash, key, value, null); 
 
                          // 链表长度大于8时，将链表转红黑树 
 
                          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 
 
                      p = e; 
 
                  } 
 
              } 
 
              // 如果存在这个映射就覆盖 
 
              if (e != null) { // existing mapping for key 
 
                  V oldValue = e.value; 
 
                  // 判断是否允许覆盖，并且value是否为空 
 
                  if (!onlyIfAbsent || oldValue == null) 
 
                      e.value = value; 
 
                  afterNodeAccess(e);     // 回调以允许LinkedHashMap后置操作 
 
                  return oldValue; 
 
              } 
 
          } 
 
          ++modCount;     // 更改操作次数 
 
          if (++size > threshold)     // 大于临界值 
 
              // 将数组大小设置为原来的2倍，并将原先的数组中的元素放到新数组中 
 
              // 因为有链表，红黑树之类，因此还要调整他们 
 
              resize();   
 
          // 回调以允许LinkedHashMap后置操作 
 
          afterNodeInsertion(evict); 
 
          return null; 
 
      }

resize() 解析：

 
  //初始化或者扩容之后元素调整 
 
  final Node<K,V>[] resize() { 
    
          // 获取旧元素数组的各种信息 
 
          Node<K,V>[] oldTab = table; 
 
          // 长度      
 
          int oldCap = (oldTab == null) ? 0 : oldTab.length; 
 
          // 扩容的临界值 
 
          int oldThr = threshold; 
 
          // 定义新数组的长度及扩容的临界值 
 
          int newCap, newThr = 0; 
 
          if (oldCap > 0) {   // 如果原table不为空 
 
              // 如果数组长度达到最大值，则修改临界值为Integer.MAX_VALUE 
 
              if (oldCap >= MAXIMUM_CAPACITY) { 
    
                  threshold = Integer.MAX_VALUE; 
 
                  return oldTab; 
 
              } 
 
              // 下面就是扩容操作（2倍） 
 
              else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && 
 
                       oldCap >= DEFAULT_INITIAL_CAPACITY) 
 
                  // threshold也变为二倍 
 
                  newThr = oldThr << 1; 
 
          } 
 
          else if (oldThr > 0) // initial capacity was placed in threshold