HashMap剖析(1.7和1.8)

源码剖析HashMap

JDK1.7

阅读源码之前,我们带着下列问题去思考:
1)数据存储结构是什么?
2)初始化时的操作?
3)当同一位置key冲突如何处理?
4)动态扩容#resize如何实现的?

构造方法

public HashMap1_7() {
    //使用默认的初始容量（16）和默认的加载因子（0.75）构造一个空的 HashMap 
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);

}

• 创建无参的HashMap集合是,初始化容量为16,加载因子为0.75
• 容量 *加载因子=扩容阈值,即16*0.75=12;阈值为12,当元素个数到达12时会扩容到原来的2倍.

put

public V put(K key, V value) {
    // 当插入第一个元素的时候，需要先初始化数组大小
    if (table == EMPTY_TABLE) {
        // 数组初始化
        inflateTable(threshold);

    }
    // 如果 key 为 null，感兴趣的可以往里看，最终会将这个 entry 放到 table[0] 中
    if (key == null)

        return putForNullKey(value);
    // 1. 求 key 的 hash 值
    int hash = hash(key);
    // 2. 找到对应的数组下标
    int i = indexFor(hash, table.length);
    // 3. 遍历一下对应下标处的链表，看是否有重复的 key 已经存在，如果有，直接覆盖，put 方法返回旧值就结束了
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {

        Object k;

        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) { // key -> value

            V oldValue = e.value;

            e.value = value;

            e.recordAccess(this);

            return oldValue;

        }

    }


    modCount++;
    // 4. 不存在重复的 key，将此 entry 添加到链表中
    addEntry(hash, key, value, i);

    return null;

}

• 如何table为空数组,则会#inflateTable初始化数组大小,数组的大小必须是2的次方,以及计算跨容的阈值.具体代买如下:

    private void inflateTable(int toSize) {
    
        // Find a power of 2 >= toSize 保证数组大小一定是 2 的 n 次方。
        // new HashMap(519)，大小是1024
        int capacity = roundUpToPowerOf2(toSize);
    
        // 计算扩容阈值：capacity * loadFactor
        threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
        // 初始化数组
        table = new Entry[capacity];
    
        initHashSeedAsNeeded(capacity);
    }
  

• 获取key的hash值,再通过数组长度和hash值计算出存储的索引位置,遍历该数组位置下的链表,如果存在相同的key则覆盖原来的value,如果不存在则调用#addEntry将当前key的entry添加到链表下一个元素.

addEntry

创建Entry<K,V>并关联链表的最后一个元素.

void addEntry(int hash, K key, V value, int bucketIndex) {
            // 如果当前 HashMap 大小已经达到了阈值，并且新值要插入的数组位置已经有元素了，那么要扩容
            if ((size >= threshold) && (null != table[bucketIndex])) {
                // 扩容，容量 * 2
        resize(2 * table.length);
        // 扩容以后，重新计算 hash 值
        hash = (null != key) ? hash(key) : 0;
        // 重新计算扩容后的新的下标
        bucketIndex = indexFor(hash, table.length);

    }

    // 创建元素
    createEntry(hash, key, value, bucketIndex);

}

• 添加Entry时会先判断HashMap的容量是否到达阈值,如果超过则需要进行扩容到 当前容量的2倍 再重新计算hash值和数组索引位置.
• #createEntry创建Entry并将他与链表的最后一个节点关联

流程图

JDK1.8变动

我们还是以#put方法为例子,分析它与1.7有什么区别?

put

public V put(K key, V value) {
    // 计算 key 的hash值并进入putValue方法
    return putVal(hash(key), key, value, false, true);
}

• 这里计算 key 的hash值并进入putValue方法

putVal

将 Key-value 存储的方法.

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)
        n = (tab = resize()).length;
    // 如果索引位置没有其他元素，直接Node添加到指定索引的数组位置
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        Node<K,V> e; K k;
        // 如果该位置的key已经存在，覆盖旧的value
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            //将Node添加到 红黑树 中
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                if ((e = p.next) == null) {
                    // 将链表最后一个节点（next）关联当前Node
                    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 = e;
            }
        }
        // key存在则 覆盖原有的value
        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;
}

• 链表长度达到8以上进入#treeifyBin转化红黑树的逻辑.

treeifyBin

该方法为转化成红黑树的判断逻辑

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // 虽然链表长度超过了8个,但如果数组的长度小于64,则对数组进行扩容.
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    // 链表节点个数达到8个以上的情况下,数组长度不小于64,则将链表转化成红黑树数据结构存储
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        TreeNode<K,V> hd = null, tl = null;
        do {
            // 将Node 转成 TreeNode 节点
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

• JDK1.7和JDK1.8的HashMap最大的区别:如果链表节点个数超过8个并且数组长度不小于64的话,JDK1.8会将链表转成红黑树数据结构存储;而JDK1.7不会将链表转成红黑树结构存储.