HashMap源码分析整理（1.8）
结构
HashMap中的变量及含义
// 默认初始容量，必须是2的n次幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量，满足2的n次幂的同时，小于等于此值
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子，决定map的扩容时机
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表转红黑树阈值，单链表长度达到此值时转为红黑树
static final int TREEIFY_THRESHOLD = 8;
// 红黑树转链表的阈值，红黑树的节点数小于此值时红黑树还原成单链表
static final int UNTREEIFY_THRESHOLD = 6;
// 链表转红黑树的另一个约束条件，如果需要转红黑树时，map容量小于此值，则优先进行resize扩容
static final int MIN_TREEIFY_CAPACITY = 64;
// 第一次使用的时候初始化，必要的时候扩容. 当分配完，大小始终是2的n次幂.
transient Node<K,V>[] table;
// 缓存entrySet()的结果
transient Set<Map.Entry<K,V>> entrySet;
// map大小
transient int size;
// 对map的操作次数
transient int modCount;
// 扩容阈值，根据容量*负载因子计算
int threshold;
// 负载因子
final float loadFactor;
存入map中的所有key value都会封装成一个Node对象来存储，当产生hash冲突时，形成单向链表，next指向下一个元素
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
当单链表需要转成红黑树来存储时，Node会换成TreeNode
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
HashMap使用Node数组来存放元素
transient Node<K,V>[] table;
操作
put操作
1.计算hash
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);
}
当调put方法存放元素至map中时，先根据key计算hash值；如果key值是null时直接返回0，如果不是null则让hashCode的低16位异或上高16位，让高低位都参与到计算中来，增加散列效果
2.计算元素位置
p = tab[i = (n - 1) & hash])
通过key计算出hash之后，由hash值与上数组下标的最大值，来计算当前元素在数组中的位置。如果返回0，则永远在数组中index=0的这个位置，即key为null值得元素存放在数组的第一个位置；当key不是null时，因为HashMap的大小始终是2的n次幂，所以n-1的二进制全部是1，与上hash之后的结果完全取决于hash的后几位。
3.判断是否初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
执行put操作之前，判断map的数组是否执行了初始化，如果没有，则调用resize方法执行容量从0至初始容量的扩容操作
4.目标位置没有元素
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
当目标位置没有元素时，直接将key、value封装成Node对象之后存放在目标位置
5.目标位置存在元素且满足"==“或"equals”
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
当目标位置存在元素时，如果目标位置元素的hash值与当前存放的key的hash值一样，且key值满足 “==” 或 “equals”，则替换元素的值，并将旧值返回
6.目标位置元素是红黑树
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
如果目标位置元素的key与当前key值不满足"==" 或 “equals”，且是以红黑树结构存储(以hash值大小来维护红黑树)，则从树中逐级查找是否存在节点满足"==“和"equals”，如果存在，则将值替换后返回旧值，如果不存在则在原来的树种新增节点
7.目标位置是单链表
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;
}
如果目标位置存放的是链表，则从链表头向后查找满足"=="和"equals"的元素替换其值并返回旧值，如果找不到则新增节点到链表尾端，此时如果链表长度到达链表转红黑树的阈值（默认是8），则将链表以hash值大小为基准构建红黑树
如果本次put操作是替换操作，直接返回旧值；如果是新增操作，会在返回前递增modCount和size并检查扩容阈值threshold，如果size超过了阈值，需要扩容，调resize方法，将容量从2的n次幂扩至2的n+1次幂
get操作
计算hash
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
查找元素
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
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 TreeNode)
return ((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;
}
1.如果目标位置不存在元素直接返回null
2.如果目标位置存在元素，且满足"==" 或 “equals”，返回这个元素
3.如果目标位置存在元素，且是红黑树结构，依据hash值的大小，在树中查找元素满足"==" 或 “equals"的元素并返回，否则返回null
4.如果目标位置存在元素，且是单链表结构，从头节点向尾端遍历，直到找到满足”==" 或 "equals"的元素返回，否则返回null
remove操作
计算hash
public boolean remove(Object key, Object value) {
return removeNode(hash(key), key, value, true, true) != null;
}
查找元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
查找流程跟get操作一样，如果找不到元素，返回null；如果找到元素，检查元素的value是否跟传递进来的value值一样，如果一样，分情况进行删除
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
1.如果找到的元素是红黑树的节点，调TreeNode.removeTreeNode方法删除节点
2.如果找到的元素是单独元素或者单链表的头节点，直接将元素的next指向的元素存到数组中
3.如果是单链表的非头节点，将被删元素的前一个节点的next指针，指向被删元素的后一个节点
扩容
初始容量
调用HashMap的无参数构造器时，默认的数组大小为16
// 16
newCap = DEFAULT_INITIAL_CAPACITY;
// 0.75f * 16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
HashMap的大小是有上限的，MAXIMUM_CAPACITY = 2^30
static final int MAXIMUM_CAPACITY = 1 << 30;
调用指定初始容量的构造器时，根据指定的初始容量，计算出比这个容量大的最小2的n次幂，下面这个算法就是为了找到最小2的n次幂。比如，当cap = 9时，n = cap - 1 = 8 = 1000，n >>> 1 = 0100，n |= n >>> 1结果为n=1100，n >>> 2 = 0011，n |= n >>> 2结果为1111，1111 = 15，15 + 1 = 16，所以实际初始大小为16。所以这个算法就是为了把二进制32位以内的所有位都变成1，结果即 2^n - 1。
为什么HashMap的大小必须为2的n次幂呢，因为通过hash值与上size-1来计算下标位置，如果size不是2的n次幂，比如15，15的二进制表示为1111，那么数组下标的最大值为1110，hash值与1110做与运算，永远得不到0001，0011，0101，1001，0111，1011，1101这几个值，即数组的1、3、5、7、9、11、13都不会有值存放，不但浪费了空间，存同样数量元素，哈希碰撞的几率也更大，也就意味着链表（或红黑树）长度大，查询速度效率低
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
当HashMap创建完成之后，并没有初始化table数组，而是在第一次存放元素的时候才会通过resize方法执行初始化操作
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 省略
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 省略
负载因子
负载因子默认为0.75f，可以通过构造器指定负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
负载因子决定threshold的大小，向map中put元素时，会检查大小递增后是否超过了阈值threshold，如果超过了，则需要扩容
if (++size > threshold)
resize();
扩容迁移
当一个非空的map执行扩容时，原来元素在新数组中的位置可能需要重新计算了；因为HashMap的位置确定是通过hash & size - 1，扩容前后size - 1的区别仅仅是最高位的1，比如扩容前8 - 1 = 111，扩容后16 - 1 = 1111，假如hash的第四位为0时，那么hash & 111 和 hash & 1111的结果是一样的，也就是说计算出的元素位置是一样的，那么只要满足 hash & 1000 = 0，下标就不需要重新计算，1000恰好是扩容前的大小；如果 hash & 1000 = 1，那么hash & 111 和 hash & 1111的结果相差1000，即原index + 1000为新的位置。
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
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 TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
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;
}
}
}
}
}
从数组的第一个元素开始向后遍历，根据元素的类型是链表还是红黑树来分情况处理：
- 元素既非链表也非红黑树，直接计算新的位置赋值
- 元素为单链表，遍历单链表，通过hash & oldCap结果是否0拆分为两个链表，为0时下标仍然为index，结果为1时下标为index + oldCap
- 元素为红黑树，遍历红黑树通过hash & oldCap结果是否0拆分为两条单链表，如果拆分后的链表长度仍满足红黑树要求，则重建红黑树，如不满足，将TreeNode替换为Node，还原成单链表
扫一扫
342
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
