HashMap源码解析
全文围绕JDK8 来讲解hashmap
1.HashMap的存储结构
hashMap采用的哈希表的方式存储，采用一个数组的存储不同哈希值的数据。相同哈希值的数据，会存放于同一个数组单元之中，最开始是以链表的形式去存储数据，采用尾插入的形式进行插入。当达到一个阈值( binCount >= TREEIFY_THRESHOLD - 1 )的时候，将会执行treeifyBin方法构建红黑树。
众所周知，当数据量大的时候链表遍历带来的影响会很大( 时间复杂度O(n) ),因此转换为红黑树将会大幅提升效率( 时间复杂度(logn) )
红黑树知识补充:
每个节点只有两种颜色：红色或者黑色
根节点必须是黑色
每个叶子节点（NIL）都是黑色的空节点
从根节点到叶子节点，不能出现两个连续的红色节点
从任一节点出发，到它下边的子节点的路径包含的黑色节点数目都相同
2.HashMap常量
以下是复制于源码，中文是机翻
//默认的初始化容量为16，必须是2的n次幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量，在两个带参数的构造函数隐式指定更高值时使用。必须是 2 的幂 <= 1<<30。
static final int MAXIMUM_CAPACITY = 1 << 30;
// 在构造函数中未指定时使用的负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 使用树而不是列表的 bin 计数阈值。将元素添加到至少具有这么多节点的 bin 时，bin 会转换为树。该值必须大于 2 且至少应为 8，以与树移除中关于在收缩时转换回普通 bin 的假设相匹配。
static final int TREEIFY_THRESHOLD = 8;
// 在调整大小操作期间取消（拆分）bin 的 bin 计数阈值。应小于 TREEIFY_THRESHOLD，最多为 6 以在移除下进行收缩检测。
static final int UNTREEIFY_THRESHOLD = 6;
// 可以将 bin 树化的最小表容量。 （否则，如果 bin 中的节点过多，则表将调整大小。）应至少为 4 * TREEIFY_THRESHOLD，以避免调整大小和树化阈值之间发生冲突。
static final int MIN_TREEIFY_CAPACITY = 64;
// 表，在第一次使用时初始化，并根据需要调整大小。分配时，长度始终是 2 的幂。 （我们还在某些操作中容忍长度为零，以允许当前不需要的引导机制。）
transient Node<K,V>[] table;
// 保存缓存的 entrySet()。请注意，AbstractMap 字段用于 keySet() 和 values()。
transient Set<Map.Entry<K,V>> entrySet;
// 此映射中包含的键值映射数。数组个数
transient int size;
// 该 HashMap 被结构修改的次数该字段用于在 HashMap 的 Collection-views 上创建迭代器快速失败。 （请参阅 ConcurrentModificationException）。
transient int modCount;
//数组扩容阈值
int threshold;
//加载因子
final float loadFactor;
// 基本哈希 bin 节点，用于大多数条目。 （请参阅下面的 TreeNode 子类，以及 LinkedHashMap 中的 Entry 子类。）
static class Node<K,V> implements Map.Entry<K,V> {
//key的hash值，put和get的时候都需要用到它来确定元素在数组中的位置
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;
}
}
// 树箱的条目。扩展 LinkedHashMap.Entry（进而扩展节点），因此可以用作常规节点或链接节点的扩展。
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
//当前节点的父节点
TreeNode<K,V> parent;
//左孩子节点
TreeNode<K,V> left;
//右孩子节点
TreeNode<K,V> right;
//指向前一个节点
TreeNode<K,V> prev; // needed to unlink next upon deletion
//当前节点是红色或者黑色的标识
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
}
3.put()方法，插入的流程
/*
将指定值与此映射中的指定键相关联。如果映射先前包含键的映射，则旧值将被替换。
参数：
key – 与指定值关联的键
value – 要与指定键关联的值
返回：
与 key 关联的先前值，如果没有 key 的映射，则为 null。 （空返回也可以表明映射先前将空与键相关联。）
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
先通过计算key的哈希值，计算hashcode 的方法由各自实体各自实现，并通过位异或右移计算把hashcode充分打散，减低hash冲突的概率。
那倒是怎么通过位运算打散的呢？下面我们来做一个例子
原始hash位值: 1100 1100 1001 0110 1001 1010 1000 0100
右移16的位值: 0000 0000 0000 0000 1100 1100 1001 0110
异或加右移16的位值 : 1100 1100 1001 0110 0101 0110 0001 0010
根据这个例子 我们看到，结果是对后16位进行了位异或运算。保留了高16位的特征，对低位进行异或运算，尽可能保持高16位的特征，从而降低哈希碰撞的概率。
再结合 当前数组的长度算出当前key在数组中是第几个元素
tab[i = (n - 1) & hash] // n是数组长度，hashmap的初始长度是16
进入这里有两个判断，定位到数组下标的元素是否为空，若为空则新建一个节点，该节点后续将会以一个链表的连接起后面的节点。
tab[i] = newNode(hash, key, value, null); // 详细结构参考上面的Node
如果已经存在元素，则进入else 块
HashMap.Node<K,V> e; K k;
// 当前位置元素的hash值等于传过来的hash，并且他们的key值也相等，则把p赋值给e 进入下一步操作。
// 这里判断第一个是因为如果是链表结构的话，头结点是不会再判断的了，只会判断后面的结点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果p的结构是一个红黑树的结构
else if (p instanceof HashMap.TreeNode)
e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 进入到这里就表明了，key的hash相同，key值不一样，不是树结构，就代表这里是链表的结构,采用尾插的方式，把节点插入到链表最后面
for (int binCount = 0; ; ++binCount) {
// 一直遍历链表，直到去到链表最后一个元素中，p.next==null 代表该节点是链表最后一个节点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 这个是判断当前链表的数量是否大于等于8个，要是成立，则将链表树化。因为链表一长，插入和查询效率将会大大降低
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 跟第一个判断一样，判断是否同一个key，若同一个key，则进入下一步操作，等等进行覆盖的操作
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 这个循环里的第一个if 是指向下一个结点的，并赋值给了e。（这jdk的写法真恶心）
p = e;
}
}
// 进入这里代表key本来就存在了，产生了冲突，结点位置不变，替换旧值
if (e != null) { // existing mapping for key
V oldValue = e.value;
// onlyIfAbsent 为true 不改变值， 但如果旧值是null的话，依然会替换。
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 这里在hashMap是一个空实现，在linkedHashMap才会具体实现。是根据访问先后顺序对元素进行排序
// 这是在node被访问后需要做的操作。
afterNodeAccess(e);
return oldValue;
}
具体对链表的插入已经讲解的差不多了。我们还漏了一部分，就是当他超过预设阈值，采用红黑树的插入方式，这里就大致列举一下，因为重点还是hashmap。
final HashMap.TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
HashMap.TreeNode<K,V> root = (parent != null) ? root() : this;
for (HashMap.TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
// key值一样的节点
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
//
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
HashMap.TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
dir = tieBreakOrder(k, pk);
}
// 判断是左子树还是右子树 并判断是否为空，不为空继续往下一个结点走
HashMap.TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
HashMap.Node<K,V> xpn = xp.next;
HashMap.TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((HashMap.TreeNode<K,V>)xpn).prev = x;
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
最后在putVal的后面还有一段代码
++modCount;
// 如果size > (容量*负载因子) 重新扩容
if (++size > threshold)
resize(); // 下面细讲
// 在HashMap中是一个空实现，具体实现在linkedHashMap中 是节点插入之后的操作
afterNodeInsertion(evict);
4.resize()方法实现的内容
当size > 负载数 则进行重新计算容量（新增，删除都会重新计算）
HashMap.Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 现有容量是否大于0 如果这个判断进入 一定是经历过一次resize的
if (oldCap > 0) {
// 容量大于 hashMap 设置的最大容量 将用Integer 最大值作为负载值
if (oldCap >= MAXIMUM_CAPACITY) { // 1 << 30
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 扩容：新容量=旧容量的两倍，阈值也是直接2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 现有容量等于0，但阈值数大于0。这种情况一般出现在有参构造的情况下，其实也是相当于一种初始化
// public HashMap(int initialCapacity, float loadFactor)
// 在这种情况下 会出现容量为0，oldThr 大于0的情况 并配合下面 if(newThr == 0)使用
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // 都是0，代表是初始化，都是用默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 为的是计算出阈值
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
// 我们可以发现，在构造函数时，并没有创建数组，在第一次调用put方法，导致resize的时候，才会把数组创建出来。这是为了延迟加载，提高效率。
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
上面代码讲解的是对HashMap容量处理的代码，下面就讲到因为扩容导致的重新hash的代码，有可能产生红黑树拆成多个，和退化成红黑树的情况。
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
HashMap.Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 链表只有一个节点 就把头结点挪动到新的位置上
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 如果是红黑树，需要拆成多个树，必要时退化成链表
else if (e instanceof HashMap.TreeNode)
((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 到这里说明，这是一个长度大于 1 的普通链表，则需要计算并判断当前位置的链表是否需要挪到新的位置
else { // preserve order
// 旧位置头尾节点
HashMap.Node<K,V> loHead = null, loTail = null;
// 新位置头尾节点
HashMap.Node<K,V> hiHead = null, hiTail = null;
HashMap.Node<K,V> next;
// 遍历链表，直至找到尾部
do {
next = e.next;
//如果当前元素的hash值和oldCap做与运算为0，则原位置不变
if ((e.hash & oldCap) == 0)
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
5.get()详细解析
我们理解完put之后，理解get就事半功倍了。
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final HashMap.Node<K,V> getNode(int hash, Object key) {
HashMap.Node<K,V>[] tab; HashMap.Node<K,V> first, e; int n; K k;
// 跟put对应，get时计算所在数字的下标，计算是一样的
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 总是检查头结点，哈希值一样，值一样就直接返回第一个
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 第一个找不到，并且改值下面有值
if ((e = first.next) != null) {
// 如果是树结构则使用红黑树的找节点的方法
if (first instanceof HashMap.TreeNode)
return ((HashMap.TreeNode<K,V>)first).getTreeNode(hash, key);
// 不是的话遍历链表直至找到最后一个
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
后续有空继续补充红黑树相关知识和其他方法的解析,以及LinkedHashMap,HashSet
扫一扫
455
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
