Java容器源码（五）——HashMap源码分析（基于JDK8）

文章目录

• （一）、知识点总结
• （二）、拉链法
• （三）、类名
• （四）、成员变量
• （五）、Node节点类
• （六）、构造方法
• （六）、tableSizeFor方法
• （七）、hash方法
• （八）、putMapEntries方法以及putVal方法
• （九）、resize方法
• （十）、remove方法
• （十一）、clear方法
• （十二）、containsValue方法

（一）、知识点总结

1. HashMap是主要用来存放键值对的，它是基于Hash表的Map实现，是Java的常用集合之一。
2. HashMap与ArrayList和LinkedList的区别：ArrayList是基于数组实现的数据结构，LinkedList则是基于链表实现的数据结构，HashMap则是利用拉链法将数组与链表相结合的数据结构，兼具数组和链表的优势。
3. 在JDK1.8之后，HashMap引入红黑树进行优化。当链表节点的个人超过8的时候，会将链表转换为红黑树，达到优化的效果。
4. HashMap是线程不安全的，无序的，允许存放key为null，也允许value为null。

（二）、拉链法

1. 拉链式的散列算法是基于数组和链表实现的。
2. 例如，图中首先计算出hash值为19，同时bucket(桶)数组的长度又为16，因此计算index = 35%16，故index=3.
3. 算出index=3之后，发现bucket中的3号位置已经有19和3号节点了，那就只能将35号节点插在19和3的后面。
4. 同时可以注意到图中数组的12号位置，节点个数超过8，因此将链表转换为红黑树，达到优化查询和插入的效果。
   

（三）、类名

public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable

1. HashMap继承自AbstractMap，同时实现了Map接口，Cloneable接口，Serializable接口
2. AbstractMap：实现了Map接口。这样可以让HashMap只需要实现自己额外需要的方法，而不需要重复实现Map接口中的方法，实现了代码的复用。
3. Map接口：这里只是起到一个标志作用，因为AbstractMap中已经实现过Map接口中的方法了。
4. Cloneable接口：这里主要实现了浅克隆的功能。
5. Serializable接口：这里主要是实现了序列化的功能。

（四）、成员变量

/**
* 默认的数组初始容量为16
* 1<<4代表移位操作，左移动4位，相当于1*2*2*2*2=16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

/**
* 数组的最大容量
* 也就相当于最大容量为2的30次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;

/**
*  默认的负载因子为0.75
*  例如，默认的数组容量为16，默认的负载因子为0.75
*  因此，当所有链表节点个数的总合>容量*负载因子的时候，就需要进行扩容
*  因为如果节点的个数过多的话，会造成大量的哈希冲突，链表过长，导致插入和查询效率低下
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;

/**
* 当某个链表上的节点个数超过8的时候，就会将该链表转换为红黑树
*/
static final int TREEIFY_THRESHOLD = 8;

/**
* 当某个链表上的节点个数小于6的时候，又会将红黑树转化为链表。
*/
static final int UNTREEIFY_THRESHOLD = 6;

/**
* 当桶的容量最少为MIN_TREEIFY_CAPACITY，也就是64的时候，才会转换为红黑树
* 如果没有达到64的话，优先选择是将桶扩容，而不是转换为红黑树
*
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 这里的table也就是相当于上面提到的桶，永远都是2的幂次方个
*/
transient Node<K,V>[] table;

/**
* 存储具体元素的集合
*/
transient Set<Map.Entry<K,V>> entrySet;

/**
* 存放元素的个数，这个不是等于桶的个数，而是所有节点的个数
*/
transient int size;

/**
* 修改次数
*/
transient int modCount;

/**
*  阈值，元素的个数不能超过阈值
* threshold = Capacity(容量)*loadFactor（负载因子）
* 当实际个数超过threshold的时候，就会进行扩容
*/
int threshold;

/**
* 对应于上面的DEFAULT_LOAD_FACTOR，这个是实际的负载因子。
*/
final float loadFactor;

1. 上面的注释都解释的比较清晰，这里就不啰嗦了。比较需要注意的成员变量是localFactor（负载因子），threshold（阈值）。这两个成员变量在后面的代码中会频繁涉及到

（五）、Node节点类

/**
* Node节点类，继承自Map.Entry<K,V>
*/
static class Node<K,V> implements Map.Entry<K,V> {
//哈希值
final int hash;
//key
final K key;
//value
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; }
//重写hashCode()方法
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}

public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//重写equal方法
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;
}
}

1. 这里只介绍了Node节点类，也就是链表的节点类，方法的作用根据方法名其实可以大致猜出来。如果有不明白的，就在评论区说一下。这里就不放更加详细的注释了，不是很难
2. 其实还有一个TreeNode节点类的，但是因为涉及到红黑树，需要了解红黑树的知识，解释起来比较麻烦，这里就不过多阐述了。如果想要了解红黑树在HashMap中的应用的，可以参考其他文章。

（六）、构造方法

/**
* 两个参数的构造方法，参数的初始容量initialCapacity，负载因子loadFactor
*/
public HashMap(int initialCapacity, float loadFactor) {
//判断initialCapacity是否小于0，小于0则抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//判断initialCapacity是否大于最大容量，如果大于，就将initialCapacity设置为MAXIMUM_CAPACITY
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//判断负载因子是否小于等于0或者非数字，如果是，就抛出异常。
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//设置loadFactor
this.loadFactor = loadFactor;
//这里先假设tableSizeFor(initialCapacity)是一个确定具体容量的方法
//因为实际的容量必须为2的幂次方，所有initialCapacity可能不符合要求，需要修正
//下面会具体解释这个方法
this.threshold = tableSizeFor(initialCapacity);
}

/**
* 一个参数的构造函数
* 参数为初始容量initialCapacity
* 调用上面的两个参数的构造方法
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

/**
* 无参构造方法
* 使用默认的负载因子
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}

/**
* 传入一个Map类型的m，将m中的所有元素放进HashMap中
* 因为没有设置负载因子，所以设置负载因子为默认的负载因子
* 这里先假设putMapEntries(m, false)是将m中的元素方式HashMap中的方法
* 下面会具体解释这个方法
*/
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}

1. HashMap的构造方法主要有四个：
   
2. 第一个是无参构造方法，使用默认的负载因子进行初始化
3. 第二个是含有初始容量的构造方法，同样使用默认的负载因子进行初始化
4. 第三个是既含有初始容量，又含有负载因子的构造方法
5. 第四个是传入一个Map，将Map中的元素传入到HashMap中

（六）、tableSizeFor方法

/**
* 将参数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;
}

1. 这个方法主要是用来规范初始化容量的，因为构造方法中传入的initialCapacity可能并不是2的幂次方，但是规定了数组的容量必须是2的幂次方，所以需要此方法来找到大于或等于initialCapacity的2的幂次方。
2. 例如上图所示，传入的initialCapacity为796，并不是2的幂次方，需要进行规范。最后计算得到1024=2的10次方。
3. 因为我不太擅长作图，可能做出来的不太好看，如果不明白的话，可以在评论区评论一下，我会再解释。谢谢

（七）、hash方法

static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

1. 这是一个根据key来返回哈希值的方法
2. 这个方法是传入一个key值，然后判断key是否为null，如果为null的话，就直接返回0
3. 如果不为null，先通过hashCode()方法获取哈希值，然后将h右移16位，并进行计算结果并返回
4. 这样做的目的是尽量减少哈希冲突。

（八）、putMapEntries方法以及putVal方法

/**
* 这个方法相当于是将m中的元素添加到HashMap中
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//获取m中实际有多少个元素
int s = m.size();
//如果个数大于0
if (s > 0) {
//如果table数组不是null，就是已经初始化过了
if (table == null) { // pre-size
//使用s/loadFactor计算出需要的数组容量是多少
float ft = ((float)s / loadFactor) + 1.0F;
//查看ft是否超过了最大数组容量MAXIMUM_CAPACITY
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
//查看t是否超过了最大装载量
if (t > threshold)
//如果超过了阈值，就初始化阈值
threshold = tableSizeFor(t);
}
//table没有进行初始化过，就进行初始化
else if (s > threshold)
//这里可以理解为一个扩容的方法，下面会解释
resize();
//foreach循环遍历m中的每一个元素
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
//将m中的元素添加到HashMap中
putVal(hash(key), key, value, false, evict);
}
}
}

/**
*   这其实是一个添加元素的方法
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//查看table是否已经初始化过或者table的长度是否为0
if ((tab = table) == null || (n = tab.length) == 0)
//如果没有初始化过，就进行扩容
n = (tab = resize()).length;
/**
*	这里进行的是一个n-1 与 hash值 ，这其实就相当于前面讲到的index = key%size
*	只是这种二进制操作对于计算机来说相对较快
*	这里首先判断的是i位置上是否已经有元素了
*/
if ((p = tab[i = (n - 1) & hash]) == null)
//如果没有元素，以为着没有哈希冲突，直接创建一个节点放在数组的i位置上
tab[i] = newNode(hash, key, value, null);
else {
//否则，就表示i位置上已经有元素了，产生了哈希冲突
Node<K,V> e; K k;
//如果i位置上的第一个节点的key和将要插入的key相同，
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//将第一个元素赋值给e，用e来记录
e = p;
//否则，判断是否已经转换为红黑树了
else if (p instanceof TreeNode)
//插入红黑树中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果和i位置上的第一个值不相等，那就是i位置上后面的元素，只能逐个遍历
for (int binCount = 0; ; ++binCount) {
//如果没有遍历完后，没有发现一样的key，那就说明还没有插入过这个key
if ((e = p.next) == null) {
//将p的下一个节点指向新节点
p.next = newNode(hash, key, value, null);
//判断节点个数是否超过8个，如果超过的话，就转换为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果在遍历过程中发现有一样的key
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 用于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表
p = e;
}
}
//表示在桶中找到key相同的几点
if (e != null) { // existing mapping for key
//获得旧值
V oldValue = e.value;
//onlyIfAbsent为false或者旧值为null
if (!onlyIfAbsent || oldValue == null)
//将新值覆盖到旧值上面
e.value = value;
//访问后回调
afterNodeAccess(e);
return oldValue;
}
}
//修改次数+1
++modCount;
//如果元素的个数大于阈值
if (++size > threshold)
//进行扩容
resize();
//插入后回调
afterNodeInsertion(evict);
return null;
}

1. 这个方法我觉得是我在分析源码过程中觉得比较复杂的方法，可能有点绕
2. 不过相信根据上面的图还有注释，慢慢看还是可以看明白的

（九）、resize方法

/**
*    用于扩容的方法
*/
final Node<K,V>[] resize() {
//获取桶，赋值给oldTab
Node<K,V>[] oldTab = table;
//查看桶是否已经被初始化过了
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//获得阈值，赋值给oldThr
int oldThr = threshold;
//创建新容量，以及新阈值
int newCap, newThr = 0;
//如果桶的容量大于0
if (oldCap > 0) {
//如果桶的大小是MAXIMUM_CAPACITY，已经是最大了，就不扩容了，直接返回
if (oldCap >= MAXIMUM_CAPACITY) {
//将阈值赋值为最大整数
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果不是，那就将桶的大小扩大1倍，并且要小于最大容量
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//阈值也扩大为两倍
newThr = oldThr << 1; // double threshold
}
//如果桶没有被初始化过，但是阈值被初始化过
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);
}
//如果阈值等于0
if (newThr == 0) {
//重新计算新的阈值（容量*负载因子）
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将threshold指向新的阈值
threshold = newThr;
//根据新的容量创建新的数组
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//将table指向新的数组newTab
table = newTab;
//如果oldTab中本来就有元素，那就要将原来的元素迁移过去
if (oldTab != null) {
//利用for循环进行遍历每一个桶
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果桶中的第一个元素不为空
if ((e = oldTab[j]) != null) {
//先将这个桶赋值为null，利于gc
oldTab[j] = null;
//判断是否有多个节点
if (e.next == null)
//如果没有的话，重新静思园位置，将节点e放入新的桶中
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;
//利用位运算代替常规运算：利用哈希值与旧的容量，
//可以得到哈希值去模后，是大于等于oldCap还是小于oldCap，
//等于0代表小于oldCap，应该存放在低位，否则存放在高位
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);
//将低位链表存放在原index处
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//将低位链表存放在原index+oldCap处
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//返回新的数组
return newTab;
}

1. 下面是resize()扩容方法的详细过程：
2. 首先需要获取旧桶以及旧桶的初始容量
3. 如果旧桶已经初始化过了，并且旧桶已经是最大容量了，那就不进行扩容了，直接返回。如果不是的话，就将桶扩大一倍，并且阈值也扩大一倍。
4. 如果旧桶没有被初始化过，那么就根据默认值对新桶的成员变量进行初始化
5. 如果阈值为0的话，就需要重新确定阈值
6. 然后根据新桶的成员变量，对新桶进行初始化
7. 因为新桶的容量和旧桶的不一样，所以位置index也变了，因此需要重新计算index位置，将旧桶中的元素搬迁到新桶中。

（十）、remove方法

/**
* 删除指定key的remove方法
*/
public V remove(Object key) {
Node<K,V> e;
//调用下面的方法删除指定的key
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;
//首先查看数组是否为null，如果不为null的话就根据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;
//如果index位置上的第一个节点就是要删除的节点
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 while循环遍历找到要删除的节点
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，  且 matchValue为false，或者值也相等
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);
//如果node == p，说明要删除的节点是index位置上的第一个节点
else if (node == p)
tab[index] = node.next;
//否则，节点是在链表中间的
else
p.next = node.next;
//修改次数+1
++modCount;
//节点个数-1
--size;
//删除节点的回调函数
afterNodeRemoval(node);
return node;
}
}
return null;
}

1. 这个代码看着很长，其实并不难，下面解释下过程：
2. 首先要查看数组是否已经初始化了，如果初始化了，才能进行下面的计算
3. 要删除的节点分为三种情况。位于index桶中的第一个节点、红黑树节点、位于index桶中后面的节点。这三种情况需要进行判断，是属于哪一类情况，获得要删除的节点
4. 确定属于哪一类情况之后，再根据三种不同的情况进行节点的删除。

（十一）、clear方法

/**
* 清空每个桶的方法
*/
public void clear() {
Node<K,V>[] tab;
//修改次数+1
modCount++;
//遍历每一个桶
if ((tab = table) != null && size > 0) {
//节点个数为0
size = 0;
//将桶的第一个元素置为null，方便gc
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}

1. 这个方法的实现较为简单，就是将每个桶设置为null，方便gc

（十二）、containsValue方法

/**
*  查看HashMap中是否含有指定的balue
*/
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
//判断桶是否已经初始化了
if ((tab = table) != null && size > 0) {
//遍历每一个桶
for (int i = 0; i < tab.length; ++i) {
//获得桶中的每一个节点
for (Node<K,V> e = tab[i]; e != null; e = e.next) {
//逐个比较
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
return false;
}

1. 这个方法的实现也并不是很难，就是遍历每个桶中每个链表节点的值，如果相等就返回。