HashMap源码分析 —— 一篇文章搞定HashMap面试
本篇文章已受权微信公众号 guolin_blog （郭霖）独家发布html
HashMap是Map中最为经常使用的一种，面试中也常常会被问到相关的问题。因为HashMap数据结构较为复杂，回答相关问题的时候每每不尽人意，尤为是在JDK1.8以后，又引入了红黑树结构，其数据结构变的更加复杂，本文就JDK1.8源码为例，对HashMap进行分析；node
一、源码分析
1.1 老规矩，先上构造方法
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);
}
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);
}
复制代码
构造方法一共重载了四个，主要初始化了三个参数：面试
- initialCapacity 初始容量（默认16）： hashMap底层由数组实现+链表（或红黑树）实现，可是仍是从数组开始，因此当储存的数据愈来愈多的时候，就必须进行扩容操做，若是在知道须要储存数据大小的状况下，指定合适的初始容量，能够避免没必要要的扩容操做，提高效率
- threshold 阈值：hashMap所能容纳的最大价值对数量，若是超过则须要扩容，计算方式：threshold=initialCapacity*loadFactor（构造方法中直接经过tableSizeFor(initialCapacity)方法进行了赋值，主要缘由是在构造方法中，数组table并无初始化，put方法中进行初始化，同时put方法中也会对threshold进行从新赋值，这个会在后面的源码中进行分析）
- loadFactor 加载因子（默认0.75）：当负载因子较大时，去给table数组扩容的可能性就会少，因此相对占用内存较少（空间上较少），可是每条entry链上的元素会相对较多，查询的时间也会增加（时间上较多）。反之就是，负载因子较少的时候，给table数组扩容的可能性就高，那么内存空间占用就多，可是entry链上的元素就会相对较少，查出的时间也会减小。因此才有了负载因子是时间和空间上的一种折中的说法。因此设置负载因子的时候要考虑本身追求的是时间仍是空间上的少。（通常状况下不须要设置，系统给的默认值已经比较适合了）
咱们最常使用的是无参构造，在这个构造方法里面仅仅设置了加载因子为默认值，其余两个参数会在resize方法里面进行初始化，在这里知道这个结论就能够了，下面会在源码里面进行分析； 另一个带有两个参数的构造方法，里面对初始容量和阈值进行了初始化，对阈值的初始化方法为 tableSizeFor(int 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;
}
复制代码
第一次看大这个方法的时候，我当时的心情是：数组
接下来分析一下这个方法，对于无符号右移运算符不了解的，能够看一下这篇文章了解一下，下面偷一张图（真的是借别人的图，google搜索的,不知道是谁的，若是大佬以为太可耻，私信我我删了他）以10为例进行分析：安全
1.2 put方法
在hashMap源码中，put方法逻辑是最为复杂的，接下来先看一下源码：bash
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; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
//若是table还没有初始化，则此处进行初始化数组，并赋值初始容量，从新计算阈值
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//经过hash找到下标，若是hash值指定的位置数据为空，则直接将数据存放进去
tab[i] = newNode(hash, key, value, null);
else {
//若是经过hash找到的位置有数据，发生碰撞
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//若是须要插入的key和当前hash值指定下标的key同样，先将e数组中已有的数据
e = p;
else if (p instanceof TreeNode)
//若是此时桶中数据类型为 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);
//若是链表过长，达到树化阈值，将链表转化成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//若是链表中有新插入的节点位置数据不为空，则此时e 赋值为节点的值，跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//通过上面的循环后，若是e不为空，则说明上面插入的值已经存在于当前的hashMap中，那么更新指定位置的键值对
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//若是此时hashMap size大于阈值，则进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
复制代码
从代码看，put方法分为三种状况：微信
-
table还没有初始化，对数据进行初始化数据结构
-
table已经初始化，且经过hash算法找到下标所在的位置数据为空,直接将数据存放到指定位置多线程
-
table已经初始化，且经过hash算法找到下标所在的位置数据不为空，发生hash冲突（碰撞），发生碰撞后，会执行如下操做：
- 判断插入的key若是等于当前位置的key的话，将 e 指向该键值对
- 若是此时桶中数据类型为 treeNode，使用红黑树进行插入
- 若是是链表，则进行循环判断， 若是链表中包含该节点，跳出循环，若是链表中不包含该节点，则把该节点插入到链表末尾，同时，若是链表长度超过树化阈值（TREEIFY_THRESHOLD）且table容量超过最小树化容量（MIN_TREEIFY_CAPACITY），则进行链表转红黑树（因为table容量越小，越容易发生hash冲突，所以在table容量<MIN_TREEIFY_CAPACITY 的时候，若是链表长度>TREEIFY_THRESHOLD,会优先选择扩容，不然会进行链表转红黑树操做）
首先分析table还没有初始化的状况：
1.2.1 table还没有初始化
n = (tab = resize()).length;
复制代码
从代码能够看出，table还没有初始化的时候，会调用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)
//若是旧的容量不小于默认的初始容量，则进行扩容，容量扩张为原来的二倍
newThr = oldThr << 1; // double threshold
}
//二、阈值大于0 threshold 使用 threshold 变量暂时保存 initialCapacity 参数的值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//3 threshold 和 table 皆未初始化状况，此处即为首次进行初始化
//也就在此处解释了构造方法中没有对threshold 和 初始容量进行赋值的问题
else { // zero initial threshold signifies using defaults
//若是阈值为零，表示使用默认的初始化值
//这种状况在调用无参构造的时候会出现，此时使用默认的容量和阈值
newCap = DEFAULT_INITIAL_CAPACITY;
//此处阈值即为 threshold=initialCapacity*loadFactor
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// newThr 为 0 时，按阈值计算公式进行计算，容量*负载因子
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容量发生变化，hash值也会发生变化，须要从新计算下标
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)
//直接将数据存放到新计算的hash值下标下
newTab[e.hash & (newCap - 1)] = e;
//三、若是是TreeNode数据结构
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//四、对于链表，数据结构
else { // preserve order
//若是是链表，从新计算hash值，根据新的下标从新分组
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;
}
复制代码
resize方法逻辑比较复杂，须要静下心来一步步的分析，可是总的下来，分为如下几步：
- 首先先判断当前table是否进行过初始化，若是没有进行过初始化，此处就解决了调用无参构造方法时候，threshold和initialCapacity 未初始化的问题，若是已经初始化过了，则进行扩容，容量为原来的二倍
- 扩容后建立新的table，并对全部的数据进行遍历
- 若是新计算的位置数据为空，则直接插入
- 若是新计算的位置为链表，则经过hash算法从新计算下标，对链表进行分组
- 若是是红黑树，则须要进行拆分操做
1.3 get方法，查找
put方法分析完成以后，剩下的就很简单了，先看一下源码：
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 &&
(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;
}
复制代码
get方法相对于put来讲，逻辑实在是简单太多了
- 根据hash值查找到指定位置的数据
- 校验指定位置第一个节点的数据是key是否为传入的key，若是是直接返回第一个节点，不然继续查找第二个节点
- 若是数据是TreeNode（红黑树结构），直接经过红黑树查找节点数据并返回
- 若是是链表结构，循环查找全部节点，返回数据
- 若是没有找到符合要求的节点，返回null
在这个方法里面，须要注意的有两个地方：hash（key）和hash的取模运算 (n - 1) & hash
1.3.1 hash（key）的源码
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
复制代码
这段代码叫作扰动函数，也是hashMap中的hash运算，主要分为下面几步：
- key.hashCode()，获取key的hashCode值，若是不进行重写的话返回的是根据内存地址获得的一个int值
- key.hashCode() 获取到的hashcode无符号右移16位并和元hashCode进行^ ，这样作的目的是为了让高位与低进行混合，让二者都参与运算，以便让hash值分布更加均匀
1.3.2 取模运算 (n - 1) & hash
在hashMap的代码中，在不少地方都会看到相似的代码：
first = tab[(n - 1) & hash])
复制代码
hash算法中，为了使元素分布的更加均匀，不少都会使用取模运算，在hashMap中并无使用hash%n这样进行取模运算，而是使用(n - 1) & hash进行代替，缘由是在计算机中，&的效率要远高于%；须要注意的是，只有容量为2的n次幂的时候，(n - 1) & hash 才能等效hash%n，这也是hashMap 初始化初始容量时，不管传入任何值，都会经过tableSizeFor(int cap) 方法转化成2的n次幂的缘由，这种巧妙的设计真的很使人惊叹； 至于为何只有2的n次幂才能这样进行取模运算，这里就再也不详细叙述了，有兴趣的能够看一下一位大佬写的文章：由HashMap哈希算法引出的求余%和与运算&转换问题
1.4 remove方法，删除
了解完get方法以后，咱们再最后了解一下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;
//根据key和key的hash值，查找到对应的元素
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);
}
}
//若是查找的了元素node，移除便可
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//若是是TreeNode，经过树进行移除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//若是是第一个节点，移除第一个节点，将index下标的位置指向第二个节点
else if (node == p)
tab[index] = node.next;
else
//若是不是链表的第一个节点，则移除该节点
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
复制代码
从源码能够看出来，经过key找到须要移除的元素操做过程和get方法几乎一致，最后在查找到key对应的节点以后，根据节点的位置和类型，进行相应的移除操做就完成了，过程很是简单
1.4.0 其余源码
到这里，hashMap的源码基本就解析完成了，其他的方法和源码逻辑相对很是简单，大部分仍是使用上述代码来实现的，例如containsKey（jey），就是使用get方法中的getNode（）来判断的，因为篇幅缘由就不一一介绍。
另外，中间有很部分不影响逻辑理解的代码被一笔带过，好比 红黑树的转化，查找，删除等操做，有兴趣的能够本身进行学习，不过还有一些其余的特性须要提醒一下
最后总结一下：
- HashMap 底层数据结构在JDK1.7以前是由数组+链表组成的，1.8以后又加入了红黑树；链表长度小于8的时候，发生Hash冲突后会增长链表的长度，当链表长度大于8的时候，会先判读数组的容量，若是容量小于64会先扩容（缘由是数组容量越小，越容易发生碰撞，所以当容量太小的时候，首先要考虑的是扩容），若是容量大于64，则会将链表转化成红黑树以提高效率
- hashMap 的容量是2的n次幂，不管在初始化的时候传入的初始容量是多少，最终都会转化成2的n次幂，这样作的缘由是为了在取模运算的时候可使用&运算符，而不是%取余，能够极大的提上效率，同时也下降hash冲突
- HashMap是非线程安全的，在多线程的操做下会存在异常状况（如造成闭环（1.7），1.8已修复闭环问题，但仍不安全），可使用HashTable或者ConcurrentHashMap进行代替
相关文章
- 1. HashMap源码分析 —— 一篇文章搞定HashMap面试
- 2. 一篇文章完全读懂HashMap之HashMap源码解析
- 3. HashMap，一篇文章征服面试官
- 4. BAT面试必问HashMap源码分析
- 5. 面试必会之HashMap源码分析
- 6. HashMap：从源码分析到面试题
- 7. HashMap源码分析（一）
- 8. HashMap源码分析(一)
- 9. 【源码分析】HashMap（一）
- 10. 一篇文章搞定前端面试
- 更多相关文章...
- • TCP报文格式解析 - TCP/IP教程
- • Lua 调试(Debug) - Lua 教程
- • 三篇文章了解 TiDB 技术内幕 —— 说计算
- • 三篇文章了解 TiDB 技术内幕——说存储
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. 外部其他进程嵌入到qt FindWindow获得窗口句柄 报错无法链接的外部符号 [email protected] 无法被([email protected]@[email protected]@@引用
- 2. UVa 11524 - InCircle
- 3. The Monocycle（bfs）
- 4. VEC-C滑窗
- 5. 堆排序的应用-TOPK问题
- 6. 实例演示ElasticSearch索引查询term,match,match_phase,query_string之间的区别
- 7. 数学基础知识 集合
- 8. amazeUI 复择框问题解决
- 9. 背包问题理解
- 10. 算数平均-几何平均不等式的证明,从麦克劳林到柯西
欢迎关注本站公众号,获取更多信息
