HashMap源码分析
本文是根据JDK8进行行文的。主要讲解HashMap中的相关属性，结构，以及常用的方法，如增删改查的源码分析。
前言
作为一名编程从业人员，我们平时代码中都经常会使用到哈希表这种数据结构，但是大多数人并不了解这个数据结构的实现原理，今天带大家分析下JDK8中HashMap的实现。
一、HashMap类结构
首先我们看一个这个类的类结构。
HashMap 类定义：
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
可以看到HashMap继承了AbstractMap类，并实现了Map，Cloneable，Serializable接口。
- AbstractMap：实现了Map接口的相关功能
- Cloneable：可以被克隆
- Serializable：序列化
这里有一个有意思的现象。HashMap继承了AbstractMap类，并实现了Map接口。但是AbstractMap已经实现了Map接口。这是一个历史原因，属于jdk开发者的一个失误，List的实现类也存在这个问题。但是并不影响我们使用。
二、常用属性
在idea编译器中我们看到HashMap类中有如下这些属性，平时我们可能光使用这个HashMap类，但是并没有怎么注意过HashMap中的属性。
在讲属性之前我们先简单说下HashMap。HashMap的底层是数组+链表。当我们插入元素的时候，会根据hash算出数据要放在数组的哪个位置，如果存在hash碰撞（算出来放在数组的同一个位置）的话我们会引出链表结构，当链表中数据量大影响我们查询效率的时候我们会把链表转换成红黑树进行结构性优化。
1、DEFAULT_INITIAL_CAPACITY
DEFAULT_INITIAL_CAPACITY：默认的数组初始化长度（是数组的长度不是实际键值对的数量）
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
默认的数组长度是16，这里说明一下，HashMap中数组的长度都是2的整数次幂
2、MAXIMUM_CAPACITY
MAXIMUM_CAPACITY：最大的数组长度，当我们在使用HashMap中我们存的键值对会很多，map为了提升效率，也会相应的进行扩容数组大小，最大数组长度是MAXIMUM_CAPACITY。最大为2的30次方。
static final int MAXIMUM_CAPACITY = 1 << 30;
3、DEFAULT_LOAD_FACTOR
DEFAULT_LOAD_FACTOR ：默认负载因子。HashMap扩容并不会等数组占用满了才会扩容，那样会造成更多的哈希冲突，导致HashMap的效率变低，而是有个负载因子控制。当键值对的数量 > 数组长度 * 负载因子 时数组会进行扩容。
4、TREEIFY_THRESHOLD
TREEIFY_THRESHOLD：这个属性是JDK8新增的属性。在用map 新增数据的时候难免会发生哈希冲突（我们是通过散列的形式放在数组上的，但是难免有些数据我们会散列到同一个数组的位置上，这时候会通过链表的形式链起来，如下图所示）
java8中链表的长度超过 TREEIFY_THRESHOLD 值的时候会把链表转化成红黑树，从而提高效率。
static final int TREEIFY_THRESHOLD = 8;
5、UNTREEIFY_THRESHOLD
UNTREEIFY_THRESHOLD这个属性和TREEIFY_THRESHOLD属性相反。这个属性是当链表的数量小于这个值时会从红黑树转为普通链表。
static final int UNTREEIFY_THRESHOLD = 6;
6、table
table：就是Node类型的数组，上文说的数组就是这个东西,真正用于存放map数据的地方。数组的长度只能是2的整数次幂。
transient Node<K,V>[] table;
7、size
size:键值对的数量
transient int size;
8、threshold
threshold:表示容器当中能够存储的数据个数的阈值，当HashMap当中存储的数据的个数超过这个值的时候，HashMap底层使用的table数组就需要进行扩容。
int threshold;
9、loadFactor
loadFactor实际的负载因子。DEFAULT_LOAD_FACTOR只不过是默认的负载因子。
final float loadFactor;
三、常用构造函数
1、无参构造
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
看到jdk的源码肯定很疑惑，我们刚才一直在介绍属性的时候说table数组的长度默认是1<<4也就是16.但是在这里并没有设置数组的长度，只有把默认的负载因子0.75给了负载因子。
带着同样的疑惑，小编看了put相关的代码终于找到了端倪，中间跳过n个方法。
在空参构造中我们只是有了负载因子。
在putVal方法时，首先判断了table是否为null，当null时会调用resize方法，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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
......
之后进入到resize方法,会跑如下代码，设置table的数组大小，并设置threshold成员变量的值。主要代码如下
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;//0
int oldThr = threshold;//threshold成员变量未赋值默认为0
int newCap, newThr = 0;
...
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;
...
看了上述代码我们发现。我们在new HashMap()的时候并没有初始化数组大小，数组大小是在我们第一次put数据的时候才被初始化的，也符合延迟加载的原则。
2、public HashMap(int initialCapacity)
接下来我们介绍Hashmap的第二种构造
在讲属性的时候我们一直在讲数组长度是2的整数次幂，但是这个构造函数我们可以传非整数次幂的数字。本着怀疑的态度，阅读了相关源码。
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
发现直接调用了两个参数的构造器。我们直接在下个标题中看相关的源码。
3、public HashMap(int initialCapacity, float loadFactor)
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);
}
通过上述源码我们发现当校验完参数合法性后，直接将第二个参数赋值给了成员变量的loadFactor ，而数组容量确实执行了tableSizeFor方法。方法如下，这个方法很经典，这里不做讲解，网上介绍这个算法的文章很多。这个方法会返回一个比输入容量向上取一个最接近的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;
}
然后和空参构造一样，都是第一次put值的时候初始化数组大小，只不过和空参走的条件分支不同，运行代码如下
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;//0
int oldThr = threshold;//比构造输入的数值向上最小的2的整数次幂
int newCap, newThr = 0;
...
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
...
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;
...
4、构造函数总结
通过分析三个构造函数我们发现在初始化HashMap的时候，我们并没有初始化数组，只是修改了部分成员变量。真正修改数组大小是在put数据的时候。
四、新增改查
1、新增和修改数据
对于经常使用哈希数据结构的我们，知道HashMap的增删改查都是O（1）的操作。那么我们接下来分析下put数据的过程。
①put
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
我们看到主要调用了putVal方法，主要（不是就传了这三个参数）传递了key的哈希码，key，和value。有兴趣可以看看HashMap中的hash方法如何算哈希码，这里不做过多赘述。
②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;
// 初次新增数据会进该分支，上边讲过这里不做赘述
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
/**
* n-1与hash进行与运算，可以算出该数组应该放在数组的哪个位置
* 该分支表述数组的相应位置没数据，直接放在相应的位置上
* node中存取的数据是hash码，key和value。p是这个node元素
*/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//哈希碰撞的情况
else {
/**
* e是临时的一个node元素
* k表示是临时的key
*/
Node<K,V> e; K k;
// 如果新插入的元素的key和数组该位置的node的key是同一个。会临时赋值给e
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 如果新的元素是TreeNode类型，进行红黑树的插入操作
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 结果为普通链表时
else {
for (int binCount = 0; ; ++binCount) {
// p的next节点为空时，在链表尾端插入一个新的node节点
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。把当前node节点赋值给e
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// e中有值的话，也就是修改的操作，会覆盖原先的值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
流程图如下
2、查询数据
map中我们最常用的就是get方法了，接下来分析一下get操作。
①get
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
我们看到是调用了getNode方法
②getNode
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//table为null或者长度为0或者算出的数组的位置上没有数据直接返回null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 如果是数组中的那个key，直接返回该node
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
//如果是红黑树，从红黑树中返回node节点
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;
}
3、删除数据
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;
} 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;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
删除数据和查找有相似的地方。它的步骤如下
①判断table为null或者长度为0亦或者求出的数组数据为null，直接返回null。
②是否为数组某个位置的头链表，是赋值给node；
③如果存在后续节点，看是否是红黑树，是的话从红黑树中找到该节点，不是的话遍历链表找到该节点，找到该节点赋值给node，找不到赋值null；
④node判断不为null。为null直接返回null；
⑤是红黑树的话，删除节点，并校验是否节点数<6,是变成普通链表。并更新size
⑥是链表头node的话，直接将原先的下一个节点放进来，并更新size
⑦是链表中间节点的话，把上一个节点的next指向node的下一个节点，并更新size
1743
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
