图解HashMap源码

1. 变量

这些变量可能会在源码阅读中反复出现

• capacity： 容量，桶的数量 也就是table长度
• threshold：临界值，默认16（capacity*loadFactor）当size大于threshold的时候会进行resize
• loadFactor：加载因子 默认 0.75 减少hash冲突
• modCount：数据修改次数 Iterator初始化的时候（HashIterator构造函数）expectedModCount = modCount。在使用迭代器遍历的时候判断两个值是否一致，如果调用map的put或者remove则 modCount会变化，则会报异常，所以要用迭代器的remove方法。
• size：当前元素个数 put 的时候增加(createEntry方法) remove的时候减少 (removeEntryForKey)

2.构造函数

使用规定的容量和加载因子来创建

public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
	// 上面主要是对初始化数据的校验
    this.loadFactor = loadFactor;
    threshold = initialCapacity;
    init(); // HashMap中此方法未实现，LinkedHashMap有相应的实现
}

使用已经存在的map对象来构建HashMap

public HashMap(Map<? extends K, ? extends V> m) {
	// 取16和 size/0.75 + 1 较大值，使用默认加载因子0.75
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
    inflateTable(threshold);
    putAllForCreate(m);
}

填充table，如果table为空，初始化 table 为 x 且 x 为 2的n次数 >= threshold 之后resize 的时候 都是 table.length * 2 所以长度都是2的倍数

private void inflateTable(int toSize) {
    // roundUpToPowerOf2 中确保 toSize >= 0 ，返回一个最接近 toSize 的次方数
    int capacity = roundUpToPowerOf2(toSize);
	// threshold 最大不能超过 (1 << 30) + 1
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}

3.put源码

首先来张图整体感受下流程

put方法

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        inflateTable(threshold);
    }
    // 如果 key 为空 则特殊处理（因为下面调用key对象的hash()方法，null无法调用hash方法，会空指针）
    if (key == null)
        return putForNullKey(value);
    // 获取 key 的 hash 并获取 hash 在 table.length 的第 i 个
    int hash = hash(key);
    int i = indexFor(hash, table.length);
    // 获取 tabel[i] 的 entry, 如果为空或者链表中不存在对应的key，则调用addEntry方法
    // 如果匹配到，则用新值替换旧值，返回 oldValue
    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))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

putForNullKey

// 循环table 查看是否有 key 为null的 entry 有则话用新值替换旧值，并直接return
// 如果没有key为null 则调用 addEntry 方法 并放入table的第 0 位 （null 的 hash 都认为是 0 ）
private V putForNullKey(V value) {
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        if (e.key == null) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    addEntry(0, null, value, 0);
    return null;
}

addEntry

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 如果 size 大于等于 threshold 且 table[i] 不为空(说明要在table上面添加新的元素需要调用resize方法)
    if ((size >= threshold) && (null != table[bucketIndex])) {
        resize(2 * table.length);  // table扩容
        hash = (null != key) ? hash(key) : 0; // 对于key重新获取 hash
        bucketIndex = indexFor(hash, table.length); // 重新获取在table上的位置
    }
    // 新建节点
    createEntry(hash, key, value, bucketIndex);
}

createEntry

void createEntry(int hash, K key, V value, int bucketIndex) {
    Entry<K,V> e = table[bucketIndex];
    table[bucketIndex] = new Entry<>(hash, key, value, e); // 将新放入的值至于链表的头部
    size++; // 大小增加
}

4.扩容

查看resize方法

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    // 如果table长度已经为最大值则不处理
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }

    Entry[] newTable = new Entry[newCapacity];
    transfer(newTable, initHashSeedAsNeeded(newCapacity)); // 将
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

transfer 用新数组的length 重新获取每个key 的 index 值 并将每个放入新的table

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            if (rehash) { // 如果需要rehash 则重新用新的hashseed来获取hash
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}