HashMap
半年前对HashMap进行过一次全面透彻的源码分析，但是半年后对很多细节都遗忘了，因此希望通过blog的方式记录对HashMap源码的理解。此次主要是对常用方法进行理解和记录；
八股文概念
HashMap在Java中是一个十分常用且重要的类。在我初学Java时就开始了解其相关的八股文，在后面的面试时也经常出现。首先就常见的HashMap相关八股文进行整理。
- HashMap基本数据结构 ：1.7（数组+链表）、1.8（数组+链表+红黑树）
- 默认初始容量16，最大容量2^30
- 默认负载因子0.75
- 当链表长度超过8且数组容量>=64会进行化树，当数元素<=6会退化成链表
- 每次2倍扩容
- 数据插入方式 jdk1.7(头插法) 1.8（尾插法）
- 线程不安全，并发情况使用ConcurrentHashMap
- 发生hash冲突时的解决方法有 拉链法 或者 rehash
上面这些大概就是我最开始背过的所有HashMap相关的全部八股文。
HashMap的结构
虽然上面的八股文背的很熟，但是在很长一段时间内，我并不知道HashMap的数据结构具体长什么样的，特别是疑惑数组+链表+红黑树是怎么聚合到一起的。
HashMap中所有元素都是按节点（Node）来表示的，每个Node节点拥有Key,Value,Hash,Next几个成员变量。
刚开始添加元素没有发生Hash冲突时，数据结构就是一个数组
当发生Hash冲突时（HashMap是通过对Hash Code进行计算，得到元素应该放在数组的哪个位置，如果这个位置已经有元素了，就发生了hash冲突），在这个数组的地址处形成一个链表
当链表的长度超过了8，并且数组的容量超过了64，这时候就会将链表转换成红黑树
正式开始
父类
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
}
父类没啥特别的，就不多做解释
常量
- DEFAULT_INITIAL_CAPACITY = 1 << 4; 默认初始容量16
- MAXIMUM_CAPACITY = 1 << 30; 最大容量2的30次方
- DEFAULT_LOAD_FACTOR = 0.75f; 默认负载因子0.75
- TREEIFY_THRESHOLD = 8; 转树阈值8
- UNTREEIFY_THRESHOLD = 6; 数退化阈值6
- MIN_TREEIFY_CAPACITY = 64; 最小转换树的数组容量64
常用方法
HashMap中我们常用的方法挺多，我下面就部分方法进行一个阅读分析：
-
构造方法
-
put方法
-
get方法
构造函数-无参构造
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
这里可以看到如果不指定负载因子，默认的负载因子为0.75
构造函数-2个参数
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);
}
两个参数的构造函数可以指定初始容量和负载因子，这里可以清晰看出容量的最大值和最小值
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;
}
这段代码是啥意思，我们给一个指定容量，比如13，那么n就是12，其二进制值就是0000 0000 0000 0000 0000 0000 0000 1100，然后n和n无符号右移后与计算，与计算是有1就为1；那么这段代码的意思就比较明显了，就是将n最高位的1及后面的所有位都变成1呗，通俗讲就是将容量填充成最近的2的次方，输入的13就填充成了16
看完两个参数的构造函数，一个参数的构造函数就没有看的必要了
Put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
可以看到，put方法的终点应该是putVal方法，看putVal前我们先看下hash()
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里可以看到，HashMap的key是可以为null的。这里将key的hashCode值高16位和低16位值进行异或计算（异或相同为0，不同为1）
putVal方法
这个方法代码看上去虽然不多，但是感觉挺难读，我们逐行进行理解
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;
}
如果第一次put值，第一个if必走，因为我们没有在构造函数中看到table的赋值，这里我们先跳过resize()细节分析，该方法挺复杂的，我们放在后面进行分析。这里我们只需要知道第一次走resize()会设置threshold和table两个成员变量的值，并返回一个Node数组
final Node<K,V>[] resize() {
// 第一次进来table为null
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 第一次进来如果是无参构造，threshold也为null
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//......
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// ....
}
return newTab;
}
经过上面tab就是resize()返回的Node数组，n就是这个数组的大小，进入下一个if判断
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
这个if判断第一次也是必过，因为这时候tab[]都没有东西，i=具体的存储的下标点（数组最大下标 & hash），p等于这个具体的Node节点
这时候记录一次modCount，size加1，并判断size是否超过了阈值，如果超过了就进行一次扩容，第一次的put就结束了。
可能你会说不是还有一个afterNodeInsertion(evict)吗？我们点过去可以看到，在HashMap中其实没有东西，是为了LinkedHashMap准备的
那么第一次put结束，HashMap中 threshold，table都有了自己的值，可能你会疑问table没有看见往里面赋值操作呀，不是只定义了一个大小吗？这里可以衍生到jvm，tab指向的是table的地址，所以实际上对tab的赋值是对table的赋值。
第二次进行put,就不会进入第一个if扩容了，第二个if就判断下标是否冲突（计算出的下标是否有值），不冲突就放进tab数组，modCount加1结束
当第一次发生冲突，这是会进行下面的逻辑
这里先会判断冲突位置的hash是否的确相等，key是否相同，如果key相同，会将旧的value进行覆盖并返回
Node<K,V> e; K k;
if (p.hash == hash &&
// 这里考虑了key为null的情况
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
链化
如果hash值不等或者key值不相等，那么就会进行链化，很显然这时候的p还不是一个树节点，所以进入else的for循环，先判断了p节点有无下一个节点，这时候肯定是没有的嘛，所以就直接给p new了一个next节点e,再然后判断了下是否满足化树的第一个条件（链表长度大于等于8），这里可以看出链表是采用的尾插法；
那后面的一个if判断是啥意思呀，是当后面这个下标位置再次冲突，还得判断下这个链表上的key是否有相同的，如果有就覆盖这个值
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;
}
}
树化
上面看了链化，但是当某个点的链表长度大于等于8后，进行树化。首先会判断下这个数组的大小是否超过了64，如果没有超过，这里是选择了resize()
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
}
那我们看看这时候的resize()将会如何进行扩容逻辑，这里就是对resize()详解了
这时候的table，threshold肯定是有值的，正常情况是进入第一个if下面的else if，这里会生成一个2倍扩容的newCap，和newThr，然后会进入下面的复杂的for循环
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
// ...
}
}
return newTab;
}
这个for循环看上去就很复杂，我们慢慢分析
如果数组某个位置有值就进入判断，e就是这个下标的节点，如果这个旧的节点只有它自己，直接重新计算下标放进新的数组中去；
如果e是树节点，就尝试拆成两颗树如果树拆过后，某棵树节点小于了6，那就将这棵树退化成链表，这里就不展示详细代码了；
如果是链表就尝试将该链表拆分成两个链表，并将一个链表放进新数组的新增出下标；
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;
}
}
}
}
resize()就这些东西，基本全部看过了，回到化树的那一步，如果数组也大于了64，那就直接化红黑树了，这里不做详细解读。到这里put方法代码逻辑解读完毕，但全程我们没有看见任何锁相关的代码和逻辑，因此在并发环境下HashMap还是会出很多问题的，比如数据丢失等问题。
扫一扫
4995
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
