共计 2827 个字符，预计需要花费 8 分钟才能阅读完成。
1. 底层数据结构
HashMap 的底层数据结构有两个阶段，在 jdk1.8 以前是由数组和链表组成，jdk1.8 及当前是由数组，链表和红黑树组成。
首先数组是一个 Entry 数组，源码中对于 Entry 的定义如下：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key;}
public final V getValue() { return value;}
public final String toString() { return key + "=" + value;}
public final int hashCode() {return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {if (o == this)
return true;
if (o instanceof Map.Entry) {Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue()))
return true;
}
return false;
}
} 即 Entry 是一个蕴含 Key，Value 以及其 get 和 set 办法的一个数据结构。
因为在 Hash 过程中可能会有 Hash 统一的状况，即每一个数组的地位有可能包含不止一个 Entry 节点，因而引入了链表的构造，使其可能在同一个数组地位链接多个 Hash 值雷同的节点。又因为当链表过长的时候，遍历会耗费大量的工夫，因而 jdk1.8 后将过长（长度超过 8）的链表转化为红黑树的构造以进步查问的效率。
2. 结构的过程
先看一个 HashMap 的构造方法：
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;
this.threshold = tableSizeFor(initialCapacity);
}首先构造方法中的参数 initialCapacity 和 loadFactor 都是非必须的，如果没有指定，则默认 initialCapacity 为 16，loadFactor 为 0.75。从下面的代码能够看出默认的底层数组的大小是 16，而因子是 0.75，而且在执行构造方法的时候并没有为数组理论地调配空间，而是在执行 put 办法的时候才真正构建数组，调配空间。
3.put 办法的执行过程
put 办法的底层源码如下：
public V put(K key, V value) {return putVal(hash(key), key, value, false, true);
}
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;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {for (int binCount = 0; ; ++binCount) {if ((e = p.next) == null) {p.next = newNode(hash, key, value, null);
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;
}
}
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;
} 以上代码的逻辑能够参考上面的流程图：
4.resize 的过程
- 保留原来的数据（容量大小，扩容阈值以及具体数据等等）
-
判断本来的容量。
-
如果如果不是 0，则证实曾经初始化过。
- 如果原先的容量大于最大容量，则将阈值设置为最大，返回原来的数组。
- 如果新容量是旧容量右移一位失去的。新容量大于默认的 16，小于最大容量，将阈值扩充为原来的两倍。
- 如果是 0，则初始化，并设置阈值。
-
- 初始阈值为 0，示意采纳默认初始化过程。
- 创立新容量的数组，容量为之前你的 2 倍。
-
采纳循环遍历之前的数组、
- 如果索引 j 处只有一个数据，则应用新的数组容量从新计算 hash 值，插入到新的数组的相应地位中去。
- 如果索引 j 处是红黑树结构，采纳红黑树的散列形式。
- 如果索引 j 处是链表构造，应用链表的散列形式。
正文完
