HashMap底层原理
简述
HashMap是Java开发过程中使用最多的集合之一,其中的put(key,value)和get(key)方法,是我们在使用HashMap时最常使用的方法,但是底层的原理我们可能就了解得比较少了,或许你知道HashMap是使用hash算法,然后基于数组+链表+红黑树来实现的,或许还知道HashMap内部数组的初始长度为16,并且还能自动扩容.今天我们就来探究一下put(key,value)和get(key)这两个常用的方法的实现过程和原理.put(key,value)的原理
首先我们调用put方法的时候,方法内部会调用hash(key)方法,计算出key的hash值h,然后通过HashMap的主干部分(数组tab)的长度length来进行位与运算(length-1)&h得出一个index=(length-1)&h值,然后直接根据index的值,将Node对象放入对应的tab[index]=Node即可,如下面伪代码和图所示:
HashMap mapDemo=new HashMap()
mapDemo.put("name","Aiden")时,
Node node=new Node("name","Aiden");
int index=hash("name")&length-1,假如算出index=2
tab[2]=node;
虽然在计算index的时候采用的是均匀分布算法,但是当put的key-value越来越多时,不可避免的会出现计算的index出现重复,这个时候就需要用到链表结构了,其实我们的Node对象不仅仅是数组里面的一个元素,还是可能是一个链表的头节点,通过next指向链表的下一个Node对象节点.当出现重复index的时候则以下面的方式进行插入:
mapDemo.put("name","Aiden")时,
Node node3=new Node("galary","1K");
int index=hash("galary")&length-1
假如算出index=3,发现数组里面里面index=3的位置已经有Node对象node2了
这个时候就转换成链表结构原来的Node对象成为链表的头节点,
新put的Node对象,插入依次链表的尾部("尾插法"),如图:
另外当链表的长度达到一定值(默认为8)之后,会转换成红黑树的结构,如下图:
get(key)的原理
一般情况下,首先根据key值调用方法hash(key),通过与数组长度位与运算来计算出index值,然后直接返回tab[index].value即可.
但是当计算出的index处的Node对象是链表结构或红黑树时,应该怎么办呢,因为那里所有Node的index都是相同的.- 当是链表结构时,这个时候会使用node.next来依次遍历比较链表上每个Node对象节点的key值是否和传入的key相等,直到匹配上为止.如下伪代码和图所示:
mapDemo.get("galary");
int index=hash("galary")&length-1,假如index=3,
这个时候我们获取tab[3]发现tab[3].key为"nick",这显然不对.
那么使用链表next指向下一个元素的特性进行遍历查找
Node e=tab[3];
while((e=e.next) != null){
if("galary".equals(e.key)){//当遍历到e=Node7的时候显然要找的就是它
return e.value;
}
}
当是红黑树结构时则node实际就为TreeNode对象,由对象调用getTreeNode方法进行内部匹配,这里对红黑树的内部如何匹配就不做介绍了,感兴趣的朋友可以自行查资料.
注:
- 1. 为什么要进行位与运算来得出index呢,主要是为了实现index的均匀分布.均匀分布的原理如下:
假如一个key="water",计算water的hashcode,结果二进制的11010111010110001010001 0111。假定HashMap长度是默认的16,计算Length-1的结果为十进制的15,二进制的1111。把以上两个结果做与运算,11010111010110001010001 0111 & 1111 = 0111,十进制是7,所以 index=7。另外为什么HashMap长度是默认16或者2的幂,因为当其长度为2的幂时,length-1的二进制位全为1,比如:31的二进制为11111;63的二进制为111111,所以,Hash算法最终得到的index结果,完全取决于Key的Hashcode值的最后几位。只要输入的HashCode本身分布均匀,Hash算法的结果就是均匀的,这就就是为什么是和length-1做位与运算,而不是其他值. - 2. Node键值对用来存放key-value的,Java8之前是是使用的Entry键值对,Node和Entry均实现Map.Entry接口.
- 3. 尾插法,在链表的尾部依次插入新的Node节点,Java8之前都是使用的头插法,即每一个新的Node都替代原来的头节点,原来的头节点变成了由新的Node节点用next指向.
- 源码解读
- put(key,value)方法源码解读
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true); //此处参数内hash(key),实际上是获得key的hashCode值
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {// onlyIfAbsent值为false的时候表示直接覆盖已存在的key的value值,为true时oldValue为null则才会覆盖
Node<K, V>[] tab; // 声明一个tab数组
Node<K, V> p; // 声明一个节点Node键值对
int n, i; // n表示tab的size; 表示即将把值put到某个Node(key-value)的index
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; // 如果tab为空或者长度为0时,就初始化tab(初始长度为16),并将长度值赋给n
if ((p = tab[i = (n - 1) & hash]) == null) // 当(n - 1) & hash 位与运算的结果为key对应的index,当为控的时候
tab[i] = newNode(hash, key, value, null); // 则调用newNode方法新建一个Node对象赋值给tab[i]
else { // 进入此else的代码块,则表示tab对应index必定已存在Node对象
Node<K, V> e;
K k; // 泛型 对象k 代表key
if (p.hash == hash&& ((k = p.key) == key || (key != null && key.equals(k))))// 当对应index上的Node的hash值与传入进来的key的hash值相等并且Node的key和传入的key也相等时则覆盖value值
e = p;
else if (p instanceof TreeNode) // 当上面不成立的时候,则说明此Node可能是红黑树或者链表. 当 是红黑树的时候
e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value); // 当为红黑树时,调用putTreeVal方法,此方法内部会遍历红黑树,如果已存在则返回被覆盖的Node,否则返回null
else { // 当为链表时
for (int binCount = 0;; ++binCount) { // 循环遍历链表
if ((e = p.next) == null) { // 当p.next为空时
p.next = newNode(hash, key, value, null);// 则newNode方法新建一个Node对象赋值给p.next
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st // 当链表达到一定长度(默认8)后,调用treeifyBin方法转换成红黑树的结构
treeifyBin(tab, hash); // 当遍历到p.next为空时 则表示找到了可以放置put进来的key-value的地方,所以要结束链表遍历
}
if (e.hash == hash&& ((k = e.key) == key || (key != null && key.equals(k)))) // 当p.next不为空时,并且hash值和传入的hash值相等,key值也相等时,则覆盖值,结束循环
break; // 则表示覆盖值,结束循环
p = e; //因为链表的遍历是 p.next.next.next...这种形式,所以最后需要将e赋给p
}
}
if (e != null) { // existing mapping for key //此处是真正执行覆盖操作的地方
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null) //onlyIfAbsent传入为false,所以会直接覆盖e原来的value值
e.value = value;
afterNodeAccess(e); //afterNodeAccess此方法下面没有代码所以无实际意义
return oldValue; // 这个地方可以看出 当我们put重复的key-value时 会返回被覆盖的oldValue,虽然我们一般不关心put时候的返回值
}
}
++modCount; //modCount是统计map被修改次数的
if (++size > threshold) //当tab的size大于阈值的时候则需要调用resize方法进行扩容
resize();afterNodeInsertion(evict); //afterNodeInsertion此方法下面没有代码所以无实际意义
return null; //当put的时候不存在覆盖值的时候则返回null
}
- get(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;
if ((tab = table) != null && (n = tab.length) > 0 // 当tab不为空并且长度不为0的情况下
&& (first = tab[(n - 1) & hash]) != null) {// 并且通过hash值和长度-1的位运算计算出的table[index]不为空
if (first.hash == hash && // check匹配上的index处的节点,比较key值是否相等
((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);//红黑树TreeNode内部匹配结果
do {
if (e.hash == hash&& ((k = e.key) == key || (key != null && key.equals(k))))
//当为链表的时候则使用next指针遍历整个链表直到匹配上或者遍历完
return e;
} while ((e = e.next) != null);//当下一个节点不为空时,继续比较key值是否匹配(执行do{}代码块)
}
}
return null;
}