面试官：说一下HashMap原理，循环链表是如何产生的

Map 这样的 Key Value 在软件开发中是非常经典的结构，常用于在内存中存放数据。众所周知 HashMap 底层是基于数组 + 链表组成的，不过在 JDK1.7 和 1.8 中具体实现稍有不同。

今天我们只讲解JDK1.7版本的HashMap。

1、HashMap的数据结构图

是一个数组+链表结构

2、HashMap成员变量

/**
 * The default initial capacity - MUST be a power of two.
 */
static final int DEFAULT_INITIAL_CAPACITY = 16;/**
 * The maximum capacity, used if a higher value is implicitly specified
 * by either of the constructors with arguments.
 * MUST be a power of two <= 1<<30.
 */
static final int MAXIMUM_CAPACITY = 1 << 30;/**
 * The load factor used when none specified in constructor.
 */
static final float DEFAULT_LOAD_FACTOR = 0.75f;/**
 * The table, resized as necessary. Length MUST Always be a power of two.
 */
transient Entry<K,V>[] table;/**
 * The number of key-value mappings contained in this map.
 */
transient int size;/**
 * The next size value at which to resize (capacity * load factor).
 * @serial
 */
int threshold;/**
 * The load factor for the hash table.
 *
 * @serial
 */
final float loadFactor;

这是 HashMap 中比较核心的几个成员变量；看看分别是什么意思？

① DEFAULT_INITIAL_CAPACITY ：初始化桶大小（16），因为底层是数组，所以这是数组默认的大小。

② MAXIMUM_CAPACITY ：桶最大值。

③ DEFAULT_LOAD_FACTOR ：默认的负载因子（0.75）

④ table：真正存放数据的数组。

⑤ size：map中存放的键值对的数量。

⑥ threshold：resize扩容时的阈值。

⑦ loadFactor：负载因子，可在初始化时显式指定。

HashMap 的构造函数可以指定参数也可以无参：

public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR;threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);table = new Entry[DEFAULT_INITIAL_CAPACITY];init();
}public HashMap(int initialCapacity) {this(initialCapacity, DEFAULT_LOAD_FACTOR);
}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);// Find a power of 2 >= initialCapacity
    int capacity = 1;while (capacity < initialCapacity)capacity <<= 1;this.loadFactor = loadFactor;threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);table = new Entry[capacity];useAltHashing = sun.misc.VM.isBooted() &&(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);init();
}

默认容量为 16，负载因子为 0.75。Map 在使用过程中不断的往里面存放数据，当数量达到了 16 * 0.75 = 12 就需要将当前 16 的容量进行扩容，而扩容这个过程涉及到 rehash、复制数据等操作，所以非常消耗性能。

因此通常建议能提前预估 HashMap 的大小最好，尽量的减少扩容带来的性能损耗。

3、Entry类

根据代码可以看到真正存放数据的是：transient Entry<K,V>[] table，这个数组，那么它又是如何定义的呢？

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

Entry 是 HashMap 中的一个内部类，从它的成员变量很容易看出：

① key 就是写入时的键。

② value 自然就是值。

③ 开始的时候就提到 HashMap 是由数组和链表组成，所以这个 next 就是用于实现链表结构。

④ hash 存放的是当前 key 的 hashcode。

知晓了基本结构，那来看看其中重要的put、get方法。

4、put 方法

public V put(K key, V value) {if (key == null)return putForNullKey(value);int hash = hash(key.hashCode());int i = indexFor(hash, table.length);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;
}

① 如果 key 为空，则 put 一个空值进去。

② 根据 key 计算出 hashcode。

③ 根据计算出的 hashcode 定位出所在桶。

④ 如果桶是一个链表则需要遍历判断里面的 hashcode、key 是否和传入 key 相等，如果相等则进行覆盖，并返回原来的值。

⑤ 如果桶是空的，说明当前位置没有数据存入；新增一个 Entry 对象写入当前位置。

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

① 当调用 addEntry 写入 Entry 时需要判断是否需要扩容。

② 如果需要就进行两倍扩充，并将当前的 key 重新 hash 并定位。

③ 而在 createEntry 中会将当前位置的桶传入到新建的桶中，如果当前桶有值就会在该位置形成链表。新new的Entry会加到链表的头部。

5、get 方法

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

① 首先也是根据 key 计算出 hashcode，然后定位到具体的桶中。

② 判断该位置是否为链表。

③ 不是链表就根据 key、key 的 hashcode 是否相等来返回值。

④ 为链表则需要遍历直到 key 及 hashcode 相等时候就返回值。

⑤ 啥都没取到就直接返回 null 。

6、并发场景下出现死循环

多线程同时put时，如果同时调用了resize操作，可能会导致循环链表产生，进而使得后面get的时候，会死循环。下面详细阐述循环链表如何形成的。

resize函数

数组扩容函数，主要的功能就是创建扩容后的新数组，并且将调用transfer函数将旧数组中的元素迁移到新的数组。

void resize(int newCapacity) {Entry[] oldTable = table;int oldCapacity = oldTable.length;if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;return;}//创建一个新的Hash Table
    Entry[] newTable = new Entry[newCapacity];//将Old Hash Table上的数据迁移到New Hash Table上
    transfer(newTable);table = newTable;threshold = (int)(newCapacity * loadFactor);
}

transfer函数

transfer逻辑其实也简单，遍历旧数组，将旧数组元素通过头插法的方式，迁移到新数组的对应位置问题出就出在头插法。

void transfer(Entry[] newTable) {//src旧数组
    Entry[] src = table;int newCapacity = newTable.length;for (int j = 0; j < src.length; j++) {Entry<K,V> e = src[j];if (e != null) {src[j] = null;do {Entry<K,V> next = e.next;int i = indexFor(e.hash, newCapacity);e.next = newTable[i];newTable[i] = e;e = next;} while (e != null);//由于是链表，所以是个循环过程
        }}
}static int indexFor(int h, int length) {return h & (length-1);
}

下面举个实际例子：

① 我假设了我们的hash算法就是简单的用key mod 一下表的大小（也就是数组的长度）。

② 最上面的是old hash 表，其中的Hash表的size=2, 加载阈值为2∗0.75=1，所以key = 3, 7, 5，在mod 2以后都冲突在table[1]这里了。

③ 接下来的三个步骤是Hash表 resize成4，然后所有的<key,value> 重新rehash的过程

正常的Rehash的过程：

并发下的Rehash过程：

1）假设我们有两个线程，用红色和浅蓝色标注了一下。

我们再回头看一下transfer代码中的这个细节：

do {Entry<K,V> next = e.next; //假设线程一执行到这里就被调度挂起了
    int i = indexFor(e.hash, newCapacity);e.next = newTable[i];newTable[i] = e;e = next;
} while (e != null);

而我们的线程二执行完成了。于是我们有下面的这个样子。

注意，因为Thread1的 e 指向了key(3)，而next指向了key(7)，其在线程二rehash后，指向了线程二重组后的链表。我们可以看到链表的顺序被反转了。

2）线程一被调度回来执行

先是执行 newTalbe[i] = e；然后是e = next，导致了e指向了key(7)，而下一次循环的next = e.next导致了next指向了key(3)

3）一切安好

线程一接着工作。把key(7)摘下来，放到newTable[i]的第一个，然后把e和next往下移。

4）环形链表出现

e.next = newTable[i] 导致 key(3).next 指向了 key(7)

注意：此时的key(7).next 已经指向了key(3)，环形链表就这样出现了。

于是，当我们的线程一调用到，HashTable.get(11)时，悲剧就出现了Infinite Loop。

有人把这个问题报给了Sun，不过Sun不认为这是一个问题。因为HashMap本来就不支持并发，要并发就用ConcurrentHashmap。

这个循环链表问题只存在于JDK1.7中，在JDK1.8中使用了不同的扩容实现方式，所以不会出现这种情况。JDK1.8中HashMap是如何实现的我们后续讲解。

原作者：DIGGKR
原文链接：面试官：说一下HashMap原理，循环链表是如何产生的
原出处：掘客DIGGKR
侵删