【JDK 源码分析】HashMap 操作方法

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

public native int hashCode();

// hash：关于Key的hash码
// key，value
// onlyIfAbsent：标识，当存在相同的Key时，是否修改Value值
// evict：标识，数组是否处于创建模式
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {、
    // 声明了一个局部变量：tab（Node数组类型）
    Node<K,V>[] tab; 
    // Node指针p：
    Node<K,V> p; 
    int n, i;
    // 把HashMap中维护的table数组赋值给了tab局部变量，然后判断是否为空
    // 如果tab为空，意味着table也为空
    // n 赋值调用resize()方法【见下resize方法解析】
    if ((tab = table) == null || (n = tab.length) == 0)
      // 完成resize()
        // 第一次put时返回的是newTab，这里获得的长度默认是16，n = 16
        n = (tab = resize()).length;
    // i = (n - 1) & hash：将给定的哈希值与数组的长度进行按位与操作，
    // 并将结果作为索引位置。这个操作的目的是根据哈希值的特征，
    // 将元素尽可能均匀地分布在不同的桶中，以提高HashMap的性能和效率。
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 如果在索引位置i上没有节点，则说明没有出现Hash冲突，就newNode新建一个节点
        tab[i] = newNode(hash, key, value, null);
    // 如果出现Hash冲突的情况，就需要进行链表尾插，如果达到扩容阈值，还会进行后续的扩容操作
    // （第一次put元素就不细看这部分代码，在扩容时细看）
    else {
        // Hash冲突，链表追加元素，扩容操作......
    }
    // modCount 记录HashMap的结构修改次数的计数器
    // 作用是在迭代器遍历HashMap的过程中，用于检测并发修改异常
    // （ConcurrentModificationException）。
    ++modCount;
    // 如果table的长度达到阈值，如果达到则需要进行resize扩容操作
    if (++size > threshold)
        resize();
    // afterNodeInsertion 方法
    // 在插入新节点后负责处理可能发生的扩容和链表转换为红黑树的操作，
    // 以及更新相应的哈希表字段。这些操作保证了HashMap的性能和正确性。
    afterNodeInsertion(evict);
    return null;
}

final Node<K,V>[] resize() {
    // oldTab 指针，指向table数组：
    Node<K,V>[] oldTab = table;
    // 获取table数组长度
    // 如果时第一次put值进入这个方法的话，此时table为null，oldTab == null 为true，oldCap值返回0
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 记录HashMap中维护的threshold值，这个追维护了哈希表的容量阈值
    // 当HashMap中的元素数量达到threshold值时，会触发哈希表的扩容操作
    int oldThr = threshold;
    int newCap, newThr = 0;
    // oldCap，原table的容量，大于0代表table中有元素存在
    // 第一次put时，oldCap为0
    if (oldCap > 0) {
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
  // 第一次put时，会走到这一个分支操作：
    else {               // zero initial threshold signifies using defaults
        // DEFAULT_INITIAL_CAPACITY 默认值是 16
        newCap = DEFAULT_INITIAL_CAPACITY;
        // 新的扩容阈值被更新
        // 默认情况下：DEFAULT_LOAD_FACTOR 是 0.75
        // 计算出的 newThr 就是 12
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 如计算出来新的threshold值是0的话，新的容量 * 负载因子作为扩容阈值：
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    // 更新阈值：
    threshold = newThr;
    // 创建新的table数组：
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    // 进行新旧table的的赋值操作：
    table = newTab;
    // 只有旧table有值时才会进行接下来的操作
    // 如果是第一次put操作，此时 oldTab == null
    if (oldTab != null) {
        // 这里是进行扩容操作的代码片段，后面在分析扩容时会详细阅读！！！
    }
    // 返回新的table数组：
    return newTab;
}

void afterNodeInsertion(boolean evict) { }

void afterNodeInsertion(boolean evict) { // possibly remove eldest
    LinkedHashMap.Entry<K,V> first;
    if (evict && (first = head) != null && removeEldestEntry(first)) {
        K key = first.key;
        removeNode(hash(key), key, null, false, true);
    }
}