Java 集合框架之 Map 系列
HashMap 学习总结 - 基于JDK1.8
继承关系:
属性:
int DEFAULT_INITIAL_CAPACITY = 1 << 4: 默认初始容量 16
int MAXIMUM_CAPACITY = 1 << 30： 最大容量：2的30次方
float DEFAULT_LOAD_FACTOR = 0.75f：默认装载因子
Node<K,V>[] table: 内部实现 数组 + 链表
int size：实际使用节点数
int threshold：临界值：= 容量 * 装载因子
float loadFactor：装载因子
链表个数超过8时转为红黑树，红黑树个数6以下时转为链表，前提是整个hash表节点数 >= 64
int TREEIFY_THRESHOLD = 8;
int UNTREEIFY_THRESHOLD = 6;
int MIN_TREEIFY_CAPACITY = 64;
内部节点实现 Node：
static class Node<K,V> implements Map.Entry<K,V> {
// key的hash值
final int hash;
// key
final K key;
// value
V value;
// 下一个节点
Node<K,V> next;
...
}
hashcode计算方法:
static final int hash(Object key) {
int h;
// key的hashcode值与hashcode值无符号位移16位之后做异或，扰动1次
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
无参构造：
public HashMap() {
// 设置默装载因子为0.75
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
传入初始容量和装载因子的有参构造：
public HashMap(int initialCapacity, float loadFactor) {
// 初始容量小于0抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 出事容量大于2的30次方，设置为2的30次方
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 校验
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
// tableSizeFor方法保证初始化map时初始容量为2的n次方
this.threshold = tableSizeFor(initialCapacity);
}
注意：
实际就算设置了map初始容量大小
其内部实现的node数组table也是并没有在构造方法中做初始化操作
接下来是HashMap的重点，put方法
public V put(K key, V value) {
// 会调用putVal方法，最后两个参数是两个布尔值
// 两个布尔参数组合使用会控制是否使用LRU算法
// 第一个布尔参数是保证LinkedHashMap操作维护插入顺序的链表
// 第二个参数可以可以设置LRU算法，移除最久未使用节点
// 注意第一个和第二个布尔参数所对应在HashMap的方法都是空实现
// 是需要子类去实现的，例如LinkedHashMap就实现了第一个参数对应的方法
// 具体在下面笔记中叙述
return putVal(hash(key), key, value, false, true);
}
putVal方法（重点）
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// tab作为table的临时引用，p充当工作节点
// n为table长度，i为node所对应在table数组中的下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 第一次put时一定是会调用扩容方法的，resize方法在之后做讲解
if ((tab = table) == null || (n = tab.length) == 0)
// 将扩容后的table长度赋值给n
n = (tab = resize()).length;
// 如果代插入节点在原本table中并不存在
// 注意hash值和table数组-1 做与运算得到的元素应该插入的位置
if ((p = tab[i = (n - 1) & hash]) == null)
// 直接插入到对应位置
tab[i] = newNode(hash, key, value, null);
// 否则，该节点所对应的key可能已存在，需要做判断
else {
// e保存插入后的节点，k充当每次遍历的节点的key
Node<K,V> e; K k;
// 如果该数组对应的链表的首节点就是重复节点
// 直接保存该节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果该节点是TreeNode类型，则说明是红黑树
// 则在红黑树插入TreeNode类型节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 不然就是该hash槽插入类型之前是链表，且首节点不是重复节点
else {
// for循环遍历链表
for (int binCount = 0; ; ++binCount) {
// 如果遍历到了链表尾，则说明key没有重复，则进行插入
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是否重复
// 如果重复则将退出循环，此时e保存的就是重复key的节点
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 迭代链表
p = e;
}
}
// e != null说明e就是重复key的节点
if (e != null) { // existing mapping for key
V oldValue = e.value;
// 此处必定会执行，因为put时onlyIfAbsent设置为false
if (!onlyIfAbsent || oldValue == null)
// 将重复节点的value设置为插入节点的value
e.value = value;
// 空实现
afterNodeAccess(e);
// 返回旧的value
return oldValue;
}
}
++modCount;
// 如果插入后的size超过了临界值，则进行扩容
if (++size > threshold)
// 扩容
resize();
// 空实现
afterNodeInsertion(evict);
return null;
}
resize方法（重点）：
final Node<K,V>[] resize() {
// oldTab引用指向本来的table
Node<K,V>[] oldTab = table;
// 获取旧的table size
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 获取旧容量
int oldThr = threshold;
// 新容量, 后者是用来区分构造时有初始化map容量
int newCap, newThr = 0;
// 如果oldCap大于0，说明不是第一次添加
// 此时无需初始化，直接扩容
if (oldCap > 0) {
// 如果map容量本身就大于2的30次方，则不进行添加
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 否则扩容2倍，如果扩容后没有超出2的30次方
// 且本来的容量大于等于16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// oldThr > 0 说明构造时初始化是设置了map容量的，此时设置新容量为初始值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 否则则说明未设置初始值或者设置的为0，此时默认初始容量设置为16
else { // zero initial threshold signifies using defaults
// 否则则初始化table
// 设置容量为16
newCap = DEFAULT_INITIAL_CAPACITY;
// 装载因子为16 * 0.75 = 12
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;
// 旧表不为空则要重新hash
// 将旧的hash表中的节点重新分布到新的hash表中
if (oldTab != null) {
// 遍历哈希表
for (int j = 0; j < oldCap; ++j) {
// 采用尾插法重新hash
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;
}
}
}
}
}
return newTab;
}
再来看一下get方法:
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
get方法会调用getNode进行查询:
// 方法修饰为final，不需要子类重写
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// hash表不为空且有元素才进行查询
if ((tab = table) != null && (n = tab.length) > 0 &&
// 根据key的hash & hash表长度 - 1得到元素应该在的位置
// 赋值给first, first如果直接为null说明节点不存在
(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);
}
}
// 未找到则返回null
return null;
}
实际上containsKey方法也是利用上面的getNode方法进行查询的:
public boolean containsKey(Object key) {
return getNode(hash(key), key) != null;
}
总结:
HashMap的实现其实是数组 + 链表（哈希表）的方式
学习时需要了解：1.每个成员属性的意义 2.构造方法在干什么 3.putVal方法和resize方法 4.get方法
其每次扩容是原来的2倍，并且容量一直都是2的n次，原因是计算添加节点的所对应的数组下标时采用的是hashcode % (数组长度)，其在数组长度等于2的n次时等价于hashcode & (数组长度 - 1),并且由于数组长度为2的n次，2的n次-1的二进制编码就是全1，此时还能保证节点分布均匀。
并且JDK1.8中当数组长度大于64且链表长度大于8时将转为红黑树，避免链表查找时效率为N，长度小于6时又将退化为链表
其key可以为null， value也可以为null，key为null时将插入到数组首节点中
注意：JDK1.7中由于插入节点采用的是头插法，多线程下可能产生循环链表从而导致死循环
JDK1.8虽然改为尾插法不会导致死循环了，但是HashMap本身不是线程安全的，多线程不能使用
