本文深入分析了JDK1.8中HashMap的实现原理，包括其内部结构、关键属性及核心方法，如查找、添加和删除元素的过程，以及扩容机制。
HashMap源码分析（JDK1.8）
查看以往的文章空易缘的博客
本文是java集合源码分析第三篇，上一篇LinkedList源码分析笔记
自己学习总结的笔记，不保证完全正确，HashMap这篇相对于前面的源码分析，难度提高了很多，有写的不对的地方，还望大佬们多多指教，我会及时修正
概述
-
继承自AbstractMap抽象类，实现了Map、Cloneable、Serializable接口
-
HashMap使用了数组，链表，红黑树结构，链表和红黑树是为了解决哈希冲突
-
默认容量为16，负载因子为0.75，最大容量为2^30
-
当哈希桶容量大于64，链表长度达到8，将链表树化转化为红黑树
-
线程不安全的集合
字段信息
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//序列化ID
private static final long serialVersionUID = 362498820763181265L;
//默认的初始容量,必须是2的幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大容量，也必须是2的幂
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认使用的装载因子，当size >= load * 容量 时进行扩容操作
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表转换为红黑树的阈值，当达到8时将链表转为红黑树
static final int TREEIFY_THRESHOLD = 8;
//将红黑树转换为链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//当桶数组的容量小于该值是，优先扩容而不是树化
static final int MIN_TREEIFY_CAPACITY = 64;
}
链表节点类
不超过阈值8时使用的单链表结构，链表节点类
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;//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;
}
public final K getKey() { return key; }//返回key
public final V getValue() { return value; }//返回value
public final String toString() { return key + "=" + value; }
//根据key和value生成节点的hash值
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
//设置value并返回oldValue
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
//key的hash值和value的hash值都要相等
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
构造函数
//哈希桶容量
int threshold;
//哈希表的装载因子
final float loadFactor;
/**
*设置初始容量，使用默认的加载因子的构造方法
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
*全部都使用默认的参数
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
/**
*设置初始容量，加载因子的构造方法
*/
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//最大初始容量不能超过MAXIMUM_CAPACITY=2^30
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//加载因子不能小于0
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
tableSizeFor(cap)方法
/**
*根据传入的cap，返回一个大于等于cap的最小的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;
}
查找元素
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;
//哈希表不为null，哈希表的大小大于0，桶不为null，也就是存在key对应hash值的键值对
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//桶第一个键值对的hash值相等，key也相等，说明查找的就是桶的第一个元素
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;
}
如何确定桶的位置？
first = tab[(n - 1) & hash]
（n - 1 & hash 等同于 hash % （n - 1）
key对应的hash值对哈希表长度取余，计算hash对应哈希表中桶的下标，使用位运算是为了提高效率
如何计算hash值？
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
HashMap中key的hash值得计算没有使用默认的hashCode()产生的hash，为什么呢？
通过观察上面确定桶的下标的&运算可以发现，n一般较小，这样就导致只有低4位参与了运算，高数位没有发挥作用，我们可以通过异或运算使低数位与高数位都参与运算，加大低位信息的随机性，计算过程：
因为int值为32位二进制数，高数位为前16位，所以无符号右移16位。
重新计算 hash 的另一个好处是可以增加 hash 的复杂度。通过移位和异或运算，可以让 hash 变得更复杂，进而影响 hash 的分布性。
查找元素执行顺序:
- 判断哈希表示是否为null，判断哈希表的大小是否大于0，判断key的hash值对应的桶是否有元素
- 判断查的key是不是对应桶的第一个元素
- 不是桶的第一个元素，则需要查找链表或者红黑树，判断第一个节点的类型，判断链表结构还是红黑树
- 如果是红黑树，则使用红黑树查找节点的方法getTreeNode()
- 如果是链表结构，则从头节点开始挨个遍历，查找key对应的节点
- 没有找到则返回null
添加元素
//哈希用的桶，也就是用来存放Node头节点的数组，在初次put元素时初始化
transient Node<K,V>[] table;
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab;
//p指向当前插入位置链表的头节点
Node<K,V> p;
//n记录桶的大小，i插入元素的桶下标，i=(n - 1) & hash
int n, i;
//如果是第一次添加元素，调用resize()方法创建哈希表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果没有hash冲突，则直接存放在桶中，成为头节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//发生hash冲突
else {
Node<K,V> e; K k;
//如果新添加的节点的key与头节点相同，则将e指向该节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果新添加的节点的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);
//如果链表长度达到了树化的阈值，则调用treeifyBin()方法将链表转为树
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;
}
}
//判断要插入的key是否存在哈希表中
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;
}
插入元素顺序
- 判断哈希表是否创建，没有创建就调用resize()方法创建哈希表
- 判断是否发生hash冲突，如未发生哈希冲突，说明是第一个节点，直接放在桶中即可
- 发生hash冲突，判断是否和头节点key相同，根据需要判断是否覆盖原键值对的值
- 与头节点key不相等，判断头节点的节点类型（链表节点或树节点）；如果头节点是TreeNode类型，则说明已经是红黑树，调用putTreeVal()添加元素
- 如果头节点不是TreeNode类型，则当前是链表结构，遍历链表，如果找到相同的key，则根据条件判断是否替换key对应的value，如果没有找到相同的，则添加在链表末尾
- 如果添加节点后，链表元素个数超过树化阈值，则调用treeifyBin()方法将链表结构转为红黑树结构
- 最后size++检查是否达到扩容阈值，是否需要扩容
扩容方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//得到旧的容量值，如果为0则说明桶数组还未创建
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//扩容第一阶段，计算新的cap和新的thr
//第一个分支，桶数组已创建
if (oldCap > 0) {
//桶数组容量达到最大值，则不再扩容，将阈值扩大为Integer.MAX_VALUE
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//一般情况下扩容，扩容为原容量的2倍，阈值也扩大为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//第二分支，桶数组还未创建，但是设置了桶数组的初始容量，使用threshold保存了initCap
//使用构造方法HashMap(int cap)或HashMap(int cap,float load)创建HashMap时
else if (oldThr > 0)
newCap = oldThr;//oldThr=tableSizeFor(initialcap),找到大于或等于cap的最小2的幂
//第三分支，没有设置初始容量，也没有设置负载因子或负载因子为0，则全部使用默认值
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;//16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//0.75*16
}
//如果新的阈值溢出，则通过负载因子*newCap计算
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) {
//遍历桶数组，将所有桶中所有节点全部取出放到新的桶数组中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != 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
//因为容量翻倍，所以原来链表上的节点可能存放在原来的下标，即低位lo
//也可能存放在扩容后的新下标，即高位hi
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;//返回新的桶数组
}
扩容方法执行顺序
第一阶段：计算newCap，newThr
-
如果桶数组还未创建，构造方法没有设置，则全部使用默认数值，默认容量为16，负载因子为0.75；如果设置了initCap，通过计算得到一个大于或等于initCap的最小的2的幂值保存在threshold中作为newCap
-
如果桶数组已创建，判断当前容量是否达到最大值2^30，如果达到最大，则不再扩容；没达到最大则newCap=2oldCap，newThr=2oldThr，当计算的newThr溢出时，则通过newCap * loadFactor重新计算
第二阶段：创建新的桶数组，将键值对移动到新的桶数组中
- 遍历原桶数组，将每一个桶中的节点逐个取出，放到新的数组中
- 如果桶中的结构为红黑树，则需要将红黑树拆解放到新桶数组中
- 如果结构为链表，将链表节点分组重新映射到新的桶数组中
小结
- 扩容操作中，将原桶数组中移动到新的桶数组中后，将原桶数组中置为null，让GC可以回收内存空间
- 因为扩容是容量翻倍，所以原链表上的每个节点，现在可能存放在原来的下标，即低位lo位， 或者扩容后的下标，即高位hi位。 hi位= lo位+原哈希桶容量
- 利用哈希值 与运算 旧的容量 ，
if ((e.hash & oldCap) == 0),可以得到哈希值去模后，是大于等于oldCap还是小于oldCap，等于0代表小于oldCap，应该存放在低位，否则存放在高位
删除元素
//根据key删除节点
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//判断桶数组是否为空，确定桶的下标
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);
}
}
//删除元素节点，并维护链表和红黑树
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;
}
}
return null;
}
删除节点顺序
-
确定桶的下标
-
在相应的链表或红黑树中找到待删除的元素节点
-
删除元素节点，维护链表或红黑树
总结
- HashMap在第一次put元素时初始化
- HashMap中key的hash值没有使用默认的，key.hashCode() ^ (key.hashCode() >>> 16)
- HashMap确定桶的下标没有使用取余运算，而是使用更快的位运算–&运算
- 初始容量是大于或等于构造方法的最下的2的幂
- 负载因子太大导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。负载因子的默认值为0.75f是官方给出的一个比较好的临界值
- HashMap中的红黑树是在jdk1.8引入的，在此之前，只使用了链表；1.8后当链表长度超过8时树化，当然桶数组容量也要超过64，没有查过64前，优先扩容
- 扩容时一个代价非常大的操作，创建HashMap最好给定一个容量
HashMap与HashTable的区别
- HashTable是线程安全的，相关方法被synchronize修饰；HashMap不是线程安全的，线程安全的可以使用ConcurrentHashMap
- HashTable不允许key、value为null；HashMap允许key、value为null
- HashTable默认容量为11，HashMap为16
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
