基于 JDK 1.8
属性字段
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 初始默认容量大小，如果指定容量，容量必须是 2 的倍数
static final int MAXIMUM_CAPACITY = 1 << 30; // 最大的容量大小 1*2^30=1073741824 ，如果指定容量，容量必须是 2 的倍数
static final float DEFAULT_LOAD_FACTOR = 0.75f; // 默认负载因子
static final int TREEIFY_THRESHOLD = 8; // 超过 8 就变为 红黑树
static final int UNTREEIFY_THRESHOLD = 6; // 小于 6 变为链表
transient Node<K,V>[] table; // 存放元素的哈希桶数组
transient int size; // 当前 Map 中 键值对数量
final float loadFactor; // 负载因子
int threshold; // 当前 Map 能容纳的最大键值对数量，threshold = length * Load factor
transient int modCount; // 结构性修改的次数，用于 fail-fast 机制
构造方法
- 默认负载因子 0.75
- 初始传参不要超过 1073741824(10 亿级别)，超过这个数会被这个数代替
- tableSizeFor(int n) 将返回第一个大于 n 的为 2 的次幂的数。
- threshold = initialCapacity*loadFactor，threshold 表示当前容量的Map能包含的键值对数量。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int MAXIMUM_CAPACITY = 1 << 30;
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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);
}
// 第一个大于 n 的为 2 的次幂的数
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;
}
key 对应到哈希桶的过程
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
index = hash(key) & (length - 1)
-
若 key == null，放到数组第一位
-
key != null，调用 Object.hashCode() 方法将 key 进行 hash 得到 h
-
将 h 与 h 右移 16 位后的数值进行异或得到一个 hash 值
-
将第 3 步得到 hash 值与数组长度减一进行与运算，得到 key 在哈希桶的索引位置。
第 4 步非常巧妙，它通过 h&(table.length -1) 来得到该对象的保存位，而 HashMap 底层数组的长度总是 2的 n 次方，这是 HashMap 在速度上的优化。
当 length 总是 2 的 n 次方时，h& (length-1) 运算等价于对 length 取模，也就是 h%length ，但是 & 比 % 具有更高的效率。
插入put 方法
- (n - 1) & hash 相当于对 length 取余
- (h = key.hashCode()) ^ (h >>> 16) 高 16 位和低 16 位进行异或，是因为当桶数组比较小时候，hashcode 值比较大，避免取模只有低位生效，高位不生效的问题。
流程：
- key 进行 hash，hash 办法为：将 key 的 hashcode 值与 key 的高 16 位进行异或运行，这种运算是时间和空间的折中办法。key 若为 null，将元素放到第一位。
- 判断 HashMap 是否初始化，若没有，调用 resize() 方法进行初始化
- 将 hash 值与数组长度-1进行与，得到 tab(i) 位置
- 若 tab(i) 没有元素，直接插入。tab(i)有元素，如果 key 相同，直接替换；若为红黑树节点，进行红黑树插入逻辑；若为链表节点，循环并插入到末尾，若链表长度 >= 7 将转为红黑树（当数组长度小于 64 直接扩容）。
- 将对应节点的 value 更改为设定的值
- 是否扩容判断。
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);
}
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;
// 如果hash值相同并且相等（引用相同或者equals返回true），直接替换
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 {
// 当前hash的位置是链表节点
for (int binCount = 0; ; ++binCount) {
// 遍历到空节点
if ((e = p.next) == null) {
// 尾插法插入节点
p.next = newNode(hash, key, value, null);
// 如果当前节点长度 >= 7，转换为树
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;
}
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 数组长度小于 64 的时候直接进行扩容，而不是树化
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
- JDK 8 是先插入后扩容，JDK 7 是先扩容再插入
扩容 resize
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// table已经初始化，且容量 > 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)
// 扩容两倍的容量小于最大值并且旧容量大于默认的capacity，就直接扩容两倍
newThr = oldThr << 1; // double threshold
}
// 用 newCap 保存 threshold 值
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) {
// 若新的阈值为 0，threhold = cap * loadFactor
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
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 当前位置元素不为 null
if ((e = oldTab[j]) != null) {
// e 保存了该节点，所以将此处元素置为 null
oldTab[j] = null;
// 如果下一个节点为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;
}
-
JDK 1.7 引发的循环链表问题（参考其它博文）
-
扩容之后，节点的位置变化特点
执行运算 ： hash & oldCap ，如果为 0 放在原位置，如果不为 0，新位置为 原位置+oldCap
get
-
put 方法支持，key、value 都为 null，并且是 尾插法
-
get 方法返回 null，有两种情况：一是不包含这个键值对，二是该键值对的键 key 对应的 value 就是 null，可以通过 containsKey 方法判断 Map 是否包含该 key
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;
// 如果map不为空并且当前hash值与数组与之后值不为null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 第一个节点的 hash 值等于传进来的并且 equals 返回 true，直接返回这个节点
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;
}
问题
- 为什么使用红黑树？
虽然 AVL 可以提供更快的查找结果，但是在节点变化时，为了维持高度的平衡，在节点旋转方面，AVL 更加复杂
- JDK 1.7 用头插法、JDK 1.8 用尾插法
JDK 1.7 在多线程环境下会出现环形链表的问题，JDK 1.8 改成了尾插，但是 HashMap 依旧不能用于多线程环境。
- 为什么 table 使用 transient 修饰？
根据 Java 中的定义，被 transient 修饰的对象不能被序列化
- table 没有存满，未使用的部分序列化浪费空间
- 不同 JVM 环境中，计算 key 的 hash 值不同，在还原过程中可能出现桶位置不一样的情况。
172
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
