HashMap是我们日常编码中经常用到的一种集合，也是面试的高频问题。作为一个合格的码农，它的一些常用方法的底层源码，应当要能掌握
今天带大家一起阅读下HashMap的源码，分析它的底层实现原理。本文的源码是基于JDK1.8
1. 数据结构
这里简单介绍下，在1.8之前，HashMap数据结构是基于数组+链表，左边为哈希数组，当发生哈希冲突的时候（就是有2个元素，根据内部的哈希运算，得到在数组上的位置是一样的），就把元素放到链表中
在1.8之后，是基于数组+链表+红黑树，在链表长度超过某个阈值的时候，链表会转为红黑树，相较于链表而言，在元素很多的时候，红黑树的查找效率远高于链表
1.1 数组
数组在hashmap里面，又叫做哈希桶，位桶
transient Node<K,V>[] table; // 存储元素的数组，长度总是2的n次幂
1.2 链表
static class Node<k,v> implements Map.Entry<k,v> {
final int 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; }
public final V getValue() { return value; }
public final String toString() { return key + = + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
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;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
Node是HashMap的一个内部类，实现了Map.Entry接口，是一个键值对类，维护两个字段key和value分别代表键和值，字段next是链表的关键，可以指向链表中的下一个节点
1.3 红黑树
static final class TreeNode<k,v> extends LinkedHashMap.Entry<k,v> {
TreeNode<k,v> parent; // 父节点
TreeNode<k,v> left; //左子树
TreeNode<k,v> right;//右子树
TreeNode<k,v> prev; // needed to unlink next upon deletion
boolean red; //颜色属性
TreeNode(int hash, K key, V val, Node<k,v> next) {
super(hash, key, val, next);
}
final TreeNode<k,v> root() {
for (TreeNode<k,v> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
}
红黑树比较复杂，这里知道它是一种特殊的AVL树即可，本文不做过多赘述
2. 类的属性
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {
// 序列号
private static final long serialVersionUID = 362498820763181265L;
// 默认的初始容量是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认的填充因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 当桶上的链表长度大于这个值 并且数组的总长度大于64的时候，链表会转为红黑树
static final int TREEIFY_THRESHOLD = 8;
// 当桶(bucket)上的节点数小于这个值时树转链表
static final int UNTREEIFY_THRESHOLD = 6;
// 桶中结构转化为红黑树对应的table的最小大小
static final int MIN_TREEIFY_CAPACITY = 64;
// 存储元素的数组，总是2的幂次倍
transient Node<k,v>[] table;
// 存放具体元素的集
transient Set<map.entry<k,v>> entrySet;
// 存放元素的个数，注意这个不等于数组的长度。
transient int size;
// 每次扩容和更改map结构的计数器
transient int modCount;
// 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
int threshold;
// 填充因子
final float loadFactor;
}
3. 常用方法
3.1 put方法
// 暴露的put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
//内部调用的putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; // tab-哈希数组, p-桶的首节点, n-数组长度, i-数组的下标
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; // HashMap使用的懒加载，在第一次put的时候，初始化容量和临界值
if ((p = tab[i = (n - 1) & hash]) == null) // 如果第i个桶为空，创建新的节点。
tab[i] = newNode(hash, key, value, null);// 这里寻找桶的位置，使用(n - 1) & hash，可以解释为什么扩容长度都是2的n次幂，2的n次幂减1后在和hash位运算，能更好的散列，避免哈希冲突
else { // 如果第i个桶不为空，即发生了哈希碰撞
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p; // 插入节点的key、hash都和p相同，e = p，表示为首节点
else if (p instanceof TreeNode) // 不是首节点，判断p是否为红黑树的节点
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);//如果链表长度大于8，转换红黑树
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break; // 判断链表上是否有重复的key，如果有，跳出当前循环
p = e;
}
}
if (e != null) { // 在桶中找到了key、hash值与插入元素相同的节点
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value; // 覆盖value
afterNodeAccess(e);
return oldValue;
}
}
++modCount; // 结构修改计数器+1
if (++size > threshold)
resize(); // 实际容量大于当前阈值，扩容
afterNodeInsertion(evict);
return null;
}
put方法看起来很长 ，但是细细分析，其实步骤很简单。HashMap使用的是懒加载，在第一次put操作的时候才分配容量。
- 判断数组的长度是否为0，如果是0，第一次调用
resize方法扩容，初始化一个容量 - 根据
(n - 1) & hash计算元素在数组中的下标位置，如果这个位置是空的，在这个位置创建新的节点 - 如果第
i个桶的位置不为空，即发生了哈希碰撞，首先判断首节点的key和hash是否和要插入的元素相等，如果相等，e = p，找到了key相等的位置，后面会替换掉value - 如果首节点
key和hash都和要插入的元素不相等，就去链表或者红黑树查找，以链表中查找为例，如果遍历完链表，发现链表中没有key和hash同要插入的元素相等，那就在链表的尾部追加这个元素。遍历过程中判断链表长度是否大于8，大于8转红黑树，在treeifyBin方法中又会判断数组长度是否大于64，如果小于64还是会先扩容 - 如果找到了一个位置，
key和hash同要插入的元素相等，e = p - 如果
e != null，即在当前HashMap里面，找到一个元素的key和value同要插入的相等，那就覆盖原有的value
流程图可以概括如下
这里涉及几个重要的知识点
1、resize()扩容方法
面试有时候会问HashMap第一次扩容是在什么时候，注意，不是初始化的时候，是在第一次put的时候
// 扩容
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // 复制一个数组，在复制的数组上操作
int oldCap = (oldTab == null) ? 0 : oldTab.length; // 旧的数组的长度
int oldThr = threshold; // 旧的临界值
int newCap, newThr = 0; // 初始化new的数组长度和临界值
if (oldCap > 0) { // oldCap > 0，说明不是首次初始化
if (oldCap >= MAXIMUM_CAPACITY) { // 如果大于最大值，长度和临界值都取最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY) // 长度扩容2倍
newThr = oldThr << 1; // 临界值扩容2倍
}
else if (oldThr > 0) // initial capacity was placed in threshold
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
table = newTab;
if (oldTab != null) { // 把旧的table的数据，遍历到new中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { //下标j的哈希桶位置不为null，有值，可能发生哈希冲突
oldTab[j] = null; // 手动置null,释放内存
if (e.next == null) // 标识这个节点是首节点，没有链表和红黑树
newTab[e.hash & (newCap - 1)] = e; // 把当前元素放到新数组的一个位置
else if (e instanceof TreeNode) // 节点是红黑树结构，转移红黑树到newTab中
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 节点是链表结构，同样，转移链表到newTab中
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;
}
这里注意几个知识点
-
扩容数组的长度变为原来的2倍
-
临界值 = 长度 x 负载因子
-
扩容结束后，会把原来的数组再进行
e.hash & (newCap - 1)运算，计算在新的数组中的位置，放到新的数组中
2、容量为什么是2的n次幂
这也是面试的高频问题之一
我们看到在计算元素在数组的位置的时候，使用(n - 1) & hash，这里的n就是数组的长度。
假设我们数组的长度是10，利用上面的计算方法`(n - 1) & hash`得到的结果
1010 & 101010100101001001000 结果：1000 = 8
1010 & 101000101101001001001 结果：1000 = 8
1010 & 101010101101101001010 结果： 1010 = 10
1010 & 101100100111001101100 结果： 1000 = 8
这种散列结果，会导致这些不同的key值全部放入相同的槽中，形成链表，严重影响性能
只有2的n次方的数，在进行(n - 1) & hash计算的时候，得到的结果会更好的散列，避免哈希冲突，提高性能
3.2 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; // tab-数组 first-桶的首节点
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;// (n - 1) & hash位置的桶首节点的key、value等于查找元素的key、value，直接返回
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;
}
n - 1) & hash找到数组这个位置的节点，如果当前位置为null，直接返回null- 判断要找的节点是首节点，如果是首节点直接返回
- 不是首节点，去链表或者红黑树里寻找这个元素，找到了就返回
3.3 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;
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; // 这里的p为要删除节点的上一个节点
} 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; // 把要删除节点的上一个节点的next指针，指向要删除的节点的下一个节点
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
- 同样是计算在数组的位置，如果是首节点，直接把第二个节点置为首节点
- 如果不是首节点，去链表里面查找，如果查找到了，修改上一个节点的
next指针，指向当前节点的下一个节点 - 如果是红黑树，去红黑树里面去掉当前节点
以上就是关于HashMap的源码分析，希望对各位有所帮助。
扫一扫
318
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
