HashMap源码分析
Posted 西邮3G实验室
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了HashMap源码分析相关的知识，希望对你有一定的参考价值。
再不点蓝字关注，机会就要飞走了哦
HashMap源码分析
简述
对于每个学习java的小伙伴来说，HashMap是再熟悉不过的了，我们知道
HashMap基于哈希表的 Map 接口的实现。可是内部的机制是什么呢，让我们来一起探索探索把
1
1
1
HashMap基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。
HashMap由于所有方法都没有加锁，所以效率高但是线程不安全。
它所使用到的数据结构：
当发生散列冲突时， 就将元素存放在对应冲突的哈希表的头结点的链表后面，这个链表是一个单链表。
当一个桶上的结点数大于等于8的时候，会将这条链表转化为一个红黑树来进行数据存贮，这样的目的是减少散列冲突的时候所带来查询时间的增加。当桶上元素小于等于6时，红黑树又会转化成一条链表。
1
2
1
源码分析
//先来看一下关键字段
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认的初始容量，aka 16
static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认的填充因子
static final int TREEIFY_THRESHOLD = 8;//桶上链表转数的最大值
static final int UNTREEIFY_THRESHOLD = 6;//红黑树转链表的元素的最小值
transient Node<K,V>[] table;//哈希数组，用来进行下标索引查找元素
transient int size//此HashMap中所有元素的个数
回忆一下之前咱们学习链表时是怎么学的，先得有一个链表，然后根据链表如何来增加数据来决定这个链表的其他方法，那咱们来类比学习的来看一下HashMap的put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
HashMap的put方法是将所要存入的键值对以及键的哈希值传入putVal方法这里的hash()函数是为了减少出现同样的hash值的情况，进而减少散列碰撞。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
一个int型变量占4个字节，一个字节是8位，所以一个int型变量占32位，hash算法的处理机制是将一个键的hashcode的值与他的hashcode右移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)//当第一次放入元素时，由于整个hash表还没初始化，所以先调用resize()方法来进行初始化这个哈希表
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//在未发生散列碰撞的情况下，哈希表下标为(n - 1) & hash的元素应该为null，此时直接添加一个节点就行
tab[i] = newNode(hash, key, value, null); else {
Node<K,V> e; K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
//当是同一个桶且key是同一个key的时候，将此节点赋给e，e就不为空了
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//此处先判断此节点是不是树的节点，如果是树的节点的话就进行putTreeVal操作，当这个key是在同一颗树里面且键值一样的话，就返回这个节点，如果是新增节点的话就返回null。
else {
for (int binCount = 0; ; ++binCount) {
//因为之前已判断过是否为树节点，所以此处必然是链表的节点
if ((e = p.next) == null) {
//当节点为null的时候，新增一个节点，并且当这个桶上节点个数大于等于8的时候，将此链表转换为一颗红黑树。
p.next = newNode(hash, key, value, null); 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))))
//当此键存在于这个桶中时，就跳出循环，此时的e不为null
break;
p = e;
}
}
if (e != null) {
// 这个操作就是在上面找到了存有对应key的那个节点，在这里只需要将原来的值替换为新的值就行，无需进行增加节点的操作并结束函数
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
//只有当新增节点的时候才会执行此操作，threshold为此哈希表长度的两倍，当桶上所有的节点都总数大于这个数的时候，就证明此hashmap极易发生散列碰撞。此时就要对此哈希表进行扩容。
resize();
afterNodeInsertion(evict);
return null; }
final Node<K,V>[] resize() { Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
//这里解决的是当原哈希表存在的情况
if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; }
else if ((newCap = oldCap << 1)
<MAXIMUM_CAPACITY &&
oldCa >=DEFAULT_INITIAL_CAPACITY)
//每次扩容时，都是将哈希表扩容自原哈希表的两倍
newThr = oldThr << 1;
//新的临界值也扩为之前的两倍。
}
else if (oldThr > 0)
// 之前临界值存在，就直接把老的临界值作为新表的大小
newCap = oldThr;
else {
//当哈希表不存在的时候，初始化这个哈希表的大小
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;//设置新的哈希表
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) { 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) {
//将一条链表桶上的元素分为e.hash & oldCap等于0与非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;
}
看到这里，HashMap的put方法就算是看完了，主要是利用hash算法算出的哈希值，在经过(n - 1) & hash过程算出一个位置下标，其目的是减少散列冲突，当发生散列冲突时，就将对应的元素放于链表上，当链表的长度大于等于8的时候就将这个链表转化为一棵树，当树的节点小于等于6的时候，就将这个树转化为链表，这样的操作是为了减少查找时的时间复杂度。
然后我们在来看一下HashMap的get()方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
通过键的hash值和键的内容查找元素
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 && (first = tab[(n - 1) & hash]) != null) {
//先通过(n - 1) & hash过程算出对应hash值在哈希表中的下标，先确定他存不存在
if (first.hash == hash &&
// 当第一个节点是目标节点的时候直接返回第一个节点 ((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;
}
查找时第一次先利用哈希值确定位于哈希数组中的下标，在不发生散列碰撞的情况下，直接就可以找到元素，发生散列碰撞时，就需要在进行遍历桶的操作来查找元素，时间复杂度会大大降低。
然后我们再来看下remove()方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value;
}
这个remove()方法咱们就不细分析了，做的其实是和上面基本上一样的操作，先找到对应节点，然后将这个节点由对应桶上移除。
本期关于HashMap的源码分析就到这里啦，各位小伙伴有什么问题或者想说的，都可以在下方留言噢
微信：西邮3G实验室
微博：xiyoumobileclub@163.com
西邮移动应用开发实验室
西邮3G实验室
西邮3G实验室
以上是关于HashMap源码分析的主要内容，如果未能解决你的问题，请参考以下文章