细说java系列之HashMap原理

// 在HashMap内部用于存放插入数据的是一个名为"table"的一维Node对象数组
// Node对象为实际存放插入数据Key和Value的数据结构
transient Node<K,V>[] table;

// 外部调用插入数据的接口方法
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

// 内部真正执行数据插入的方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    if ((tab = table) == null || (n = tab.length) == 0)
        // 第一次插入数据时，初始化table数组
        n = (tab = resize()).length; 
    if ((p = tab[i = (n - 1) & hash]) == null)
        // 变量n为HashMap当前容量大小，实际上就是table数组的容量大小
        // 将(n-1)与插入数据Key的hashcode值进行逻辑与运算，找到一个随机位置i
        // 如果table[i]值为null，说明该位置还没有存放数据，新建一个Node对象并存放在table[i]，本次插入完毕，返回null值
        tab[i] = newNode(hash, key, value, null);
    else {
        // 如果table[i]值不为null，说明该位置已经存放了数据，继续寻找插入数据的位置
        Node<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            // 如果新插入数据Key的hashcode值与table[i]位置存放对象Key的hascode值相同
            // 并且新插入数据Key与table[i]位置存放对象的Key引用的是同一个对象或者它们相等（通过equals方法比较）
            // 则使用新插入数据的Value替换table[i]位置存放对象的Value，本次插入完毕，返回之前存放在该位置对象的Value值
            e = p;
        else if (p instanceof TreeNode)
            // 如果table[i]位置存放对象属于TreeNode类型，进行特别处理
            // 为什么需要判断是否为TreeNode类型？
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            // 如果新插入数据Key不与table[i]位置存放对象Key相同，那么寻找一个满足如下条件的位置，将新数据插入到对应位置
            // 条件1：如果table[i]位置对象的next属性为null，直接通过该next属性引用插入数据新建的Node对象，并返回null
            // 条件2：如果table[i]位置对象的next属性不为null，那么就在该位置对象链表上寻找一个插入新数据的位置，在这个过程中根据如下满足条件进行处理
            // 条件3：如果插入数据的Key与链表上的某个Node对象的Key相同，那么使用新插入的Value替换该Node对象的Value，并返回该Node之前的Value值
            // 如果不满足上诉3个条件，将插入数据保存在table[i]位置对象链表的末端，并返回null
            // 总结：HashMap存放实际数据的是一个一维数组，而每一个数组元素又支持链表结构
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    p.next = newNode(hash, key, value, null);
                    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;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

if (++size > threshold)
    resize();

/**
 * The array of bins. Lazily initialized upon first insertion.
 * Size is always a power of two. Accessed directly by iterators.
 */
// ConcurrentHashMap内部存储数据的table通过关键字volatile修饰，因此是线程安全的
transient volatile Node<K,V>[] table;