Java 7 HashMap 详解

HashMap<K, V>

是 AbStractMap 的子类，实现了 Map、Cloneable 和 Serializable（后面有关于 Serializable 的一个问题） 。

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

DEFAULT_INITIAL_CAPACITY（默认初始容量）

常量，值为 16，必须是 2 的幂。

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

MAXIMUM_CAPACITY（最大容量）

常量，值为 2 的 30 次幂，即使构造函数 public HashMap(int initialCapacity, float loadFactor) 和 public HashMap(int initialCapacity) 的参数 initialCapacity 比 MAXIMUM_CAPACITY 大，域 table 数组的长度仍为 MAXIMUM_CAPACITY。

static final int MAXIMUM_CAPACITY = 1 << 30;

DEFAULT_LOAD_FACTOR（默认加载因子）

常量，值为 0.75，除了构造函数 public HashMap(int initialCapacity, float loadFactor)，其它构造函数创建的 HashMap 对象的加载因子都为 DEFAULT_LOAD_FACTOR。

static final float DEFAULT_LOAD_FACTOR = 0.75f;

EMPTY_TABLE

常量，值为 Entry<?, ?> 类型的空数组，当 inflateTable 方法没有被调用时，table 域的初始值为它。为什么不用 null？Java 8 中用 null。

static final Entry<?,?>[] EMPTY_TABLE = {};

table

哈希表，必要时调整大小，长度必须总是 2 的幂。为什么长度必须总是 2 的幂？见静态方法 indexFor(int h, int length)。为什么 table 等域被修饰符 transient 修饰？ Object 类的 hashCode 方法是本地方法，在不同计算机上的返回值可能不同。

transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;

threshold

阈值，如果 table == EMPTY_table，以刚好比 threshold 大于等于的 2 的幂为长度“初始化” table。

int threshold;

loadFactor

加载因子。阈值 = 容量 * 加载因子。

final float loadFactor;

modCount

在结构上被修改的次数，结构修改是那些更改映射数或以其他方式修改内部结构（例如，rehash 方法）的次数，此字段用来使集合视图上的迭代器 fail-fast（参见 ConcurrentModificationException）。

transient int modCount;

ALTERNATIVE_HASHING_THRESHOLD_DEFAULT（替代哈希阈值默认）、Holder、hashSeed

一般情况下，指定虚拟机参数 jdk.map.althashing.threshold 开启替代哈希。

HashMap(int initialCapacity, float loadFactor)

使用 initialCapacity 和 loadFactor 构造一个空的 HashMap，先校验参数，再给 loadFactor 和 threshold 域赋值，最后调用 init 方法，在 HashMap 中，init 方法什么都不做。

在此类外和其他三个构造函数中都被调用。

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();
}

void init() {
}

HashMap(Map m)

用指定的映射构造一个新的 HashMap，它是用默认加载因子创建的，初始容量足够大，先调用构造函数，然后“初始化” table 域，最后将参数 m 中的键值映射放入 table 数组中。

public HashMap(Map<? extends K, ? extends V> m) {
    this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                  DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
    inflateTable(threshold);

    putAllForCreate(m);
}

inflateTable(int toSize)

“初始化”表。先调用 roundUpToPowerOf2 方法获得刚好比 threshold 大于等于的 2 的幂，然后初始化 threshold 和 table 域。

private void inflateTable(int toSize) {
    int capacity = roundUpToPowerOf2(toSize);

    // loadFactor 是可以大于 1 的，但是会加剧哈希冲突，所以保持默认值 0.75 就好
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}

private static int roundUpToPowerOf2(int number) {
    // assert number >= 0 : "number must be non-negative";
    return number >= MAXIMUM_CAPACITY
            ? MAXIMUM_CAPACITY
            : (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}

indexFor(int h, int length)

返回哈希的位置，长度必须总是 2 的幂，这样 h & (length - 1) 和 h % length 等价，& 的效率比 % 高。

static int indexFor(int h, int length) {
    // assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
    return h & (length-1);
}

get(Object key)

key 为空时调用 getForNullKey()，xxxForNullKey() 都是为了性能，遍历 table 数组的 0 位置，遇到 key 为空的映射，返回它的值，否则返回空。在 addEntry(int hash, K key, V value, int bucketIndex) 中，为空的 key 被放在 table 数组的 0 位置；不为空时调用 getEntry()。

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    Entry<K,V> entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

private V getForNullKey() {
    if (size == 0) {
        return null;
    }
    for (Entry<K,V> e = table[0]; e != null; e = e.next) {
        if (e.key == null)
            return e.value;
    }
    return null;
}

getEntry(Object key)

返回与参数 key 关联的 Entry 对象，先获得 key 的哈希，为了避免冲突，哈希函数被设计得很复杂，然后获得 key 在 table 中的位置，最后遍历那个位置的所有 Entry 并返回与 key 对应的 Entry。

final Entry<K,V> getEntry(Object key) {
    if (size == 0) {
        return null;
    }

    int hash = (key == null) ? 0 : hash(key);
    for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash &&
            // key 和 e.key 的引用相同（含同时为 null 的情况）
            ((k = e.key) == key ||
                (key != null && key.equals(k))))
            return e;
    }
    return null;
}

final int hash(Object k) {
    int h = hashSeed;
    // 如果禁用了替代哈希且 k 是 String 的实例
    if (0 != h && k instanceof String) {
        // sun.misc.Hashing 这个类在 JDK 8 中被移除
        return sun.misc.Hashing.stringHash32((String) k);
    }

    h ^= k.hashCode();

    // 此函数确保仅在每个位位置以常数倍数不同的哈希代码具有有限的冲突数（默认加载因子下约为 8）
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

put(K key, V value)

先确保 table 数组被初始化，key 为空时调用 putForNullKey(V value) 将 键值对放在 table 数组的 0 位置，不为空时先获得 key 的哈希，然后获得 key 在 table 中的位置，最后遍历那个位置的所有 Entry，如果找到与 key 对应的 Entry，覆盖它的值，如果找不到就调用 addEntry 方法在 table 数组中添加一个 Entry，返回值为被覆盖的值。

public V put(K key, V value) {
    // 如果 table 与 EMPTY_TABLE 共享空表实例（表未初始化时）
    if (table == EMPTY_TABLE) {
        // 对表初始化或扩容
        inflateTable(threshold);
    }
    if (key == null)
        return putForNullKey(value);
    int hash = hash(key);
    // 返回哈希值 h 的索引
    int i = indexFor(hash, table.length);
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash &&
            // key 和 e.key 的引用相同（含同时为 null 的情况）
            ((k = e.key) == key ||
                key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            // 当调用 HashMap 中已有的键 k 的 put(k，v) 覆盖条目中的值时，就会调用此方法
            e.recordAccess(this);
            return oldValue;
        }
    }

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

resize(int newCapacity)

如果旧容量为 MAXIMUM_CAPACITY，将阈值赋值为 Integer.MAX_VALUE，返回，防止此方法再次被调用。先创建容量为参数 newCapacity 的新 table，然后调用 transfer 方法转移所有的 Entry 从当前 table 到新 table，最后替换 table 和 threhold。

void resize(int newCapacity) {
    Entry[] oldTable = table;
    int oldCapacity = oldTable.length;
    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(Entry[] newTable, boolean rehash)

转移所有的 Entry 从当前 table 到新 table，被多个线程调用时可能会出现循环链表，线程不安全。

假设 table 中的某个位置如下图所示（有三个 Entry），thread1 和 thread2 都刚刚执行完 这个位置的第一次 while 循环的 Entry next = e.next;

thread1 执行完 while 循环

thread2 执行完第一次 while 循环

thread2 执行完第二次 while 循环

thread2 执行完第三次 while 循环

可能出现 CPU 占用过高的问题，结合 Linux 和 JDK 的命令一起分析：

• top 找出 CPU 占比最高的进程的 PID
• ps -ef 或 jps 进一步定位这个进程是一个什么样的后台程序
• ps -mp PID -o THREAD, tid, time 找出这个进程中 CPU 占比最高的线程的 TID
• jstack PID | grep TID 的十六进制的小写 -A60 定位到具体代码行

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) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

putAll(Map m)

先确保 table 数组被初始化，然后如果参数 m 中键值映射的数量比阈值大，用加载因子计算出目标容量，并调整 table 数组的大小为刚好大于等于目标容量的 2 的幂，最后调用 put 方法将参数 m 中的键值映射放入 table 数组中。

public void putAll(Map<? extends K, ? extends V> m) {
    int numKeysToBeAdded = m.size();
    if (numKeysToBeAdded == 0)
        return;

    if (table == EMPTY_TABLE) {
        inflateTable((int) Math.max(numKeysToBeAdded * loadFactor, threshold));
    }

    /*
     * 如果要添加的映射数大于或等于阈值，则展开映射。
     * 这是保守的；明显的条件是（m.size() + size）>= threshold，
     * 但是如果要添加的键与此映射中已有的键重叠，则此条件可能导致具有两倍于适当容量的映射。
     * 通过使用保守的计算方法，我们最多可以对自己进行一次额外的调整。
     */
    if (numKeysToBeAdded > threshold) {
        int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
        if (targetCapacity > MAXIMUM_CAPACITY)
            targetCapacity = MAXIMUM_CAPACITY;
        int newCapacity = table.length;
        while (newCapacity < targetCapacity)
            newCapacity <<= 1;
        if (newCapacity > table.length)
            resize(newCapacity);
    }

    for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
        put(e.getKey(), e.getValue());
}

clear()

将 table 域中的每个位置赋值为空，size 域赋值为 0，但 modCount 域加 1（结构修改）。

public void clear() {
    modCount++;
    Arrays.fill(table, null);
    size = 0;
}

containsValue(Object value)

如果 value 为空，返回 containsNullValue() 的返回值，因为 null 可以直接用 == 比较，对象要用 euqals 方法比较。

public boolean containsValue(Object value) {
    if (value == null)
        return containsNullValue();

    Entry[] tab = table;
    for (int i = 0; i < tab.length ; i++)
        for (Entry e = tab[i] ; e != null ; e = e.next)
            if (value.equals(e.value))
                return true;
    return false;
}

private boolean containsNullValue() {
    Entry[] tab = table;
    for (int i = 0; i < tab.length ; i++)
        for (Entry e = tab[i] ; e != null ; e = e.next)
            if (e.value == null)
                return true;
    return false;
}

Entry<K,V>

是 Map.Entry<K, V> 的子类，有 hash、key、value 和 next 四个域。在它的 equals 方法中，如果参数 o 是 Map.Entry 的实例且参数 o 的 key 和 value 域和它的相同，返回 true，否则返回 false。在它的 hashCode() 中，返回值是键的哈希与值的哈希的异或结果。

static class Entry<K,V> implements Map.Entry<K,V> {
    final K key;
    V value;
    Entry<K,V> next;
    int hash;

    /**
     * Creates new entry.
     */
    Entry(int h, K k, V v, Entry<K,V> n) {
        value = v;
        next = n;
        key = k;
        hash = h;
    }
    ...
    public final boolean equals(Object o) {
        if (!(o instanceof Map.Entry))
            return false;
        Map.Entry e = (Map.Entry)o;
        Object k1 = getKey();
        Object k2 = e.getKey();
        // k1 和 k2 的引用相同（含同时为 null 的情况）
        if (k1 == k2 ||
            (k1 != null && k1.equals(k2))) {
            Object v1 = getValue();
            Object v2 = e.getValue();
            if (v1 == v2 || (v1 != null && v1.equals(v2)))
                return true;
        }
        return false;
    }

    public final int hashCode() {
        return Objects.hashCode(getKey()) ^ Objects.hashCode(getValue());
    }
    ...
}

void addEntry(int hash, K key, V value, int bucketIndex)

如果在将键值映射放入 table 数组中之前，键值映射的数量大于等于阈值且 table 数组的对应位置不为空，以当前 table 数组长度的二倍调整大小，重新计算哈希和对应位置，调用 createEntry 方法从链表头部放入 Entry 对象。

如果不考虑调整大小，用 createEntry 方法代替 addEntry 方法。

void addEntry(int hash, K key, V value, int bucketIndex) {
    // 如果此映射中包含的键值映射数大于等于阈值且表哈希索引的位置为空
    if ((size >= threshold) && (null != table[bucketIndex])) {
        // 先扩容
        resize(2 * table.length);
        hash = (null != key) ? hash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}

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++;
}

entrySet()

entrySet() 返回 entrySet0() 的返回值。

如果 entrySet 不为空，entrySet0() 返回 entrySet；如果为空，初始化 entrySet 并返回。

entrySet 的默认值为空。

EntrySet 的构造方法继承自 AbstractSet>，什么都不做。

hashMap.forEach((key, value) -> System.out.println(key + "=" + value)); 先调用 entrySet 的 iterator() 获得迭代器，iterator() 返回 HashMap 的 newEntryIterator() 的返回值，newEntryIterator() 创建一个 EntryIterator 对象并返回。

然后通过 EntryIterator 对象的 next() 遍历 entrySet，next() 返回 nextEntry() 的返回值。

nextEntry() 先判断 modCount 与预期的是否相等和下一个 Entry 是否为空，如果相等且不为空，将下一个 Entry 的 next 域赋值给 EntryIterator 的 next 域并判断是否为空，如果为空，将 table 数组中下一个位置的 Entry 赋值给 next 域，返回下一个 Entry。

keySet() 和 values() 同理，最后返回的是 nextEntry.getKey() 的返回值和 nextEntry.value。

public Set<Map.Entry<K,V>> entrySet() {
    return entrySet0();
}

private Set<Map.Entry<K,V>> entrySet0() {
    Set<Map.Entry<K,V>> es = entrySet;
    return es != null ? es : (entrySet = new EntrySet());
}

private transient Set<Map.Entry<K,V>> entrySet = null;

private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
    public Iterator<Map.Entry<K,V>> iterator() {
        return newEntryIterator();
    }
    ...
}

public abstract class AbstractSet<E> extends AbstractCollection<E> implements Set<E> {
    ...
    protected AbstractSet() {
    }
    ...
}

Iterator<Map.Entry<K,V>> newEntryIterator()   {
    return new EntryIterator();
}

private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
    public Map.Entry<K,V> next() {
        return nextEntry();
    }
}

private abstract class HashIterator<E> implements Iterator<E> {
    Entry<K,V> next;        // next entry to return
    int expectedModCount;   // For fast-fail
    int index;              // current slot
    Entry<K,V> current;     // current entry
    
    HashIterator() {
        expectedModCount = modCount;
        if (size > 0) { // advance to first entry
            Entry[] t = table;
            while (index < t.length && (next = t[index++]) == null)
                ;
        }
    }

    public final boolean hasNext() {
        return next != null;
    }
    
    final Entry<K,V> nextEntry() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
        Entry<K,V> e = next;
        if (e == null)
            throw new NoSuchElementException();
    
        if ((next = e.next) == null) {
            Entry[] t = table;
            while (index < t.length && (next = t[index++]) == null)
                ;
        }
        current = e;
        return e;
    }
    ...
}