并发编程学习笔记（二十四、ConcurrentHashMap，Java7 HashMap简述）

目录：

• HashMap结构
• HashMap方法简述

HashMap结构

在Java7中我们可以更具HashMap的table属性及Entry内部类观察出，其底层是基于数组实现，并在发生Hash冲突的时候用链表解决，将相同hash值的key组层一个链表维护。

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

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

还有几个属性需要注意下：

• capacity：数组容量，始终保持2^n次倍，可以扩容，扩容后大小为当前数组的2倍。
• loadFactory：负载因子，默认为0.75。
• threshold：扩容阀值，等于capacity * loadFactory。

HashMap方法简述

java.util.HashMap#put：添加一个键值对到map中。

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、遍历整个map的链表，若有重复的key值则覆盖
    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++;
    // 4、不存在的key值将次添加到链表中
    addEntry(hash, key, value, i);
    return null;
}

可以看到一个key value对添加到map中有很多个步骤，接下来我们一步步的分析。

1、inflateTable(threshold)：初始化数组容量。

private void inflateTable(int toSize) {
    // toSize从上层函数的threshold可以看出，其值默认为16，或者是你自己初始化的大小
    // roundUpToPowerOf2会保证数组大小一定是2的n次方，假如你是new HashMap(20)，那么capacity的值就位32
    int capacity = roundUpToPowerOf2(toSize);

    // 计算扩容阀值：capacity * loadFactor
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    initHashSeedAsNeeded(capacity);
}

这里有一个保持数组容量为2^n的要求，同样的Java8的HashMap和ConcurrentHashMap也是如此，只不过实现略有不同而已。

那为什么要这么做呢，其实啊某些东西的特殊要求要么就是需要满足既定的条件才能实现，要么就是这样要求能更加快捷的达到目的；而我们这个就属于后者，这样写能提高HashMap计算数组下标的效率。

因为模运算（%）的效率不如位运算（&），而sun公司的大佬又发现了hash & (capacity - 1) == hash % capacity。所以就有了这一要求

参考：https://blog.csdn.net/qq_44933374/article/details/98469424

——————————————————————————————————————————————————————————————————————

2、indexFor(hash, table.length)：利用hash值计算数据放入的下标。

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

——————————————————————————————————————————————————————————————————————

3、addEntry(hash, key, value, i)：添加节点到链表中。

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

    // 将新值放入链表表头，然后增加HashMap大小
    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++;
}

4、resize(2 * table.length)：扩容。

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

代码比较简单，不多讲。

java.util.HashMap#get：根据key获取value。

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

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

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 &&
            ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

相对于put，get则更简单；根据key计算hash值，找到对应数组下标后遍历改数组的链表，直到找到==或equals的key。

虽然说不难，但想要看懂代码还是需要有链表基础的，哈哈。