本文主要从以下几个方面分析一下HashMap源码,算是对最近学习的HashMap的一个小小总结,看完JDK1.8版本的后,还会去看一下JDK1.7版本的,下面主要是基于JDK1.8版本。
1.继承关系
2.基本属性和默认值
3.构造函数
4.基本的CURD实现
在进行源码分析之前,先来说一下HashMap的底层数据结构:
HashMap就是使用哈希表来存储的,HashMap底层由数组+链表+红黑树组成(JDK1.8),哈希表解决冲突,可以采用开放地址法和链地址法等来解决问题,Java中HashMap采用了链地址法。
1.继承关系
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
由源码可知HashMap继承了AbstractMap<K,V>,实现了Map<K,V>,Cloneable,Serializable接口。
2.基本属性和默认值
//序列号,序列化的时候使用。
private static final long serialVersionUID = 362498820763181265L;
//初始默认数组的大小为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//数组的最大长度
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的负载因子为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表节点转换红黑树节点的阈值
static final int TREEIFY_THRESHOLD = 8;
//当链表节点小于6时,会将红黑树转换成普通的链表
static final int UNTREEIFY_THRESHOLD = 6;
//最小树形化的容量,即当内部数组长度小于64时,不会将链表转化成红黑树,而是优先扩充数组
static final int MIN_TREEIFY_CAPACITY = 64;
//HashMap的内部数组,而Node是链表节点对象
transient Node<K,V>[] table;
/*下面三个容器类成员,作用相同,实际类型为HashMap的内部类KeySet、Values、EntrySet。
*他们的作用并不是缓存所有的key或者所有的value,内部并没有任何元素。
*而是通过他们内部定义的方法,从三个角度(视图)操作HashMap,更加方便的迭代。
* 关注点分别是键,值,映射。
*/
transient Set<K> keySet; // AbstractMap的成员
transient Collection<V> values; // AbstractMap的成员
transient Set<Map.Entry<K,V>> entrySet;
//元素个数,注意和内部数组长度区分开来
transient int size;
//是容器结构的修改次数,fail-fast机制。
transient int modCount;
//负载因子
final float loadFactor;
3.构造函数
//构造函数 1:能够设置初始化数组长度及负载因子
public HashMap(int initialCapacity, float loadFactor) {
//如果初始容量小于0,则抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//超过了最大值,则取最大值
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);
}
//构造函数 2:能够设置初始化数组长度,对于负载因子默认0.75,会去调用构造函数1
public HashMap(int initialCapacity) {
//调用构造函数1
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//构造函数 3:默认初始化数组长度为16,负载因子0.75,会去调用构造函数1
public HashMap() {
//调用构造函数1
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//指定集合,转化为HashMap
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
4.基本的CURD实现
1、hash算法
static final int hash(Object key) {
int h;
//当我们将键值对传递给put()方法时,它调用键对象的hashCode()方法来计算hashcode,
//用hashCode的高16位与低16位进行异或运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 高位参与运算
}
2、put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//里面包含两个方法:hash(key),putVal()
//onlyIfAbsent:当存入键值对时,如果该key已存在,是否覆盖它的value。false为覆盖,true为不覆盖。
//evict:用于子类LinkedHashMap。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// tab:内部数组
// p:hash对应的索引位中的首节点
// n:内部数组的长度
// i:hash对应的索引位
Node<K,V>[] tab; Node<K,V> p; int n, i;
//table是否为空或length=0
if ((tab = table) == null || (n = tab.length) == 0)
//进行扩容
n = (tab = resize()).length;
//计算数组索引,获取该索引位置的首节点,如果为null,添加一个新的节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//表示有冲突,开始处理冲突
else {
Node<K,V> e; K k;
//如果首节点的key和要存入的key相同,那么直接覆盖value的值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//若key存在,直接覆盖value
//如果首节点是红黑树,按照红黑树的putTreeVal方法将键值对添加到红黑树
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//此时首节点是链表,若链表中存在该键值对,直接覆盖value,若不存在,则在末端插入键值对
//然后判断链表是否大于等于7,尝试转换成红黑树,因为在treeifyBin方法中还会判断当前数组容量是否达到64,
//否则会放弃这次转换,优先扩充数组容量。
else {
//走到这里,hash碰撞了,检测链表中是否包含key,或将键值对添加到链表末尾
for (int binCount = 0; ; ++binCount) {
//p.next()==null,到达链表末尾,添加新节点,如果长度大于阈值,转换成红黑树
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//检查链表中是否已经包含key
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//e不为空就是链表上有相同的key值,将该节点的value覆盖,返回oldValue
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//记录修改次数
++modCount;
//map节点数+1,如果元素个数大于阈值,阈值是初始容量*0.75
if (++size > threshold)
resize();//扩容两倍
//空操作
afterNodeInsertion(evict); //用于LinkedHashMap
return null;
}
下面简单说下添加键值对put(key,value)的过程:
1、对key求hash值,然后再计算下标
2、如果没有碰撞,直接放入桶中
3、如果有碰撞,以链表的方式链接到后面
4、如果节点已经存在就替换旧值
5、判断链表是不是红黑树,若是,调用putTreeVal()方法,按红黑树的方法链接
6、若是链表,判断目标节点存在吗,若不存在,链接在链表后面,(JDK1.8使用的尾插法)
7、若链表长度超过阈值(8),就把链表转成红黑树
8、若节点已经存在就替换旧值
9、如果桶满了(容量*加载因子),就需要resize
3、get方法
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;
//table不为空&&table长度大于0&&table索引位置(根据hash值计算出)节点不为空
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;
//first的key不等于传入的key,
if ((e = first.next) != null) {
//判断是否为红黑树,若是红黑树节点,则调用红黑树的查找目标节点方法getTreeNode
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//若是链表,循环至节点的key与传入的key值相等
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;//找不到符合的返回空
}
4、resize()方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //引用扩容前的Node数组
int oldCap = (oldTab == null) ? 0 : oldTab.length;//oldTab最大容量
int oldThr = threshold; //oldTab阈值
int newCap, newThr = 0;
//如果旧表的长度不是空
if (oldCap > 0) {
//超过最大值就不再扩充了,就只好随你碰撞,返回旧表
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//若旧表的容量,没有超过最大容量值,把新表的长度设置为旧表长度的两倍newCap=oldCap*2
//如果新容量<最大容量并且老容量>=16,则将新阈值设置为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//如果旧表的长度是0,旧表的阈值大于0,就是说第一次初始化表
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { //旧表的容量为0,旧表的阈值为0,则为空表,设置默认容量和阈值
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; //把新表赋值给新定义的表table
if (oldTab != null) { //原数组不是空,要把原数组的数据移动到新数组中
//遍历原数组
for (int j = 0; j < oldCap; ++j) {
//取出首节点
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果e.next为空,链表只有一个节点,直接重新计算索引存入新数组
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//e.next不为空,该节点是红黑树,执行split方法,和链表类似的处理
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//此时节点是链表
else { //loHead,lotail为原链表的节点,索引不变
Node<K,V> loHead = null, loTail = null;
//hiHeadm,hiTail为新链表节点,原索引+原数组长度
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//遍历链表
do {
next = e.next;
//如果e的hash值与原链表的容量进行与运算为0,则扩容后的索引位置和旧表的索引位置一样
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//如果e的hash值与原链表的容量进行与运算为1,则扩容后的索引位置为:旧表的索引位置+旧表的容量(oldCap)
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//原链表存回原索引位置
if (loTail != null) {
loTail.next = null; //最后一个节点的next设为空
newTab[j] = loHead; //将原索引位置的节点设置为对应的头节点
}
//新链表存到:原索引为+原数组长度
if (hiTail != null) {
hiTail.next = null; //最后一个节点的next设为空
//将索引位置为原索引+oldCap的节点设置为对应的头节点
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
5、treeifyBin方法,该方法是将链表转化为红黑树
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//table为空或table的长度小于64,放弃转换,扩充数组
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
//根据hash值计算索引值,遍历该索引位置的链表
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) //t1为空代表为第一次循环
hd = p; //头节点
else {
p.prev = tl; //当前节点的prev属性设为上一个节点
tl.next = p; //上一个节点的next属性设置为当前节点
}
tl = p; //t1赋值为p,在下一次循环中作为上一个节点
} while ((e = e.next) != null); //e指向下一个节点
//将table该索引位置赋值为新转的TreeNode的头节点
if ((tab[index] = hd) != null)
hd.treeify(tab); //以头节点为根节点,构建红黑树
}
}
1、什么时候转换为红黑树
当链表数目超过8,并且map节点数量超过64,才会转换为红黑树
2、什么时候扩容(前提是map数目没有超过最大容量值 1<<30 )
新增节点时,发生了碰撞,并且节点数目超过阀值
新增节点时,发生了碰撞,节点数量木有超过阀值,但是链表数目>8,map节点<64时
6、remove()方法
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;
//如果table不为空,并且根据hash值计算出来的索引位置不为空,将该位置的节点赋值给p
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;
//如果p的hash值和key都与入参的相同,则p为目标节点,赋值给node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) { //如果节点存在下一个节点
//如果p是TreeNode则调用红黑树的方法查找节点
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do { //若是链表,遍历链表查找符合条件的节点
//当节点的hash值和key与传入的相同,则该节点即为目标节点
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e; //赋值给node,并跳出循环
break;
}
p = e; //p节点赋值为本次结束的e
} while ((e = e.next) != null); //指向下一个节点
}
}
//如果node不为空(根据传入的key和hash值查找到目标节点),则进行移除操作
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode) //如果是TreeNode则调用红黑树的移除方法
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果是普通链表,如果node是该索引位置的头节点则直接将该索引位置的值赋值给node的next节点
else if (node == p)
tab[index] = node.next;
//否则将node的上一个节点的next属性设置为node的next节点,即将node节点移除,将node上下节点进行关联
else
p.next = node.next;
++modCount; //修改次数+1
--size; //table的总节点数-1
afterNodeRemoval(node); //供LinkedHashMap使用
return node; //返回被移除的节点
}
}
return null;
}