文章目录
1. 概述
HashMap是一个散列表，它存储的的是键值对的映射关系。
HashMap的实现不是同步的，是线程不安全的，但是效率高。查找的平均时间 复杂度达到了O(1)。允许null键与null值。
其默认的大小是16，装载因子是0.75。
2. jdk1.7与jdk1.8 HashMap的区别
-
数据结构的组成不同，JDK1.7使用的是数组加链表的形式。存在问题有，当hash碰撞的时候，数组中某个位置的链表会很长。这样影响了查找的速度。而JDK1.8使用的是数组加链表加红黑树的结果。HashMap中定义了一个阈值，当链表的长度等于8的时候，则将链表转换成红黑树。
这样加快了查找的速度，利用了空间来换取时间。当红黑树的大小等于6的时候，则转换成链表。选择6和8的原因，可能是为了避免经常的在两种状态间切换。绝大多数情况下链表的长度是不会到8的，因为这种情况的概率很低。 -
JDK1.7用的是头插法，而JDK1.8用的是尾插法。使用头插法的话，在扩容的时候，会导致逆序的情况。多线程的时候，由于HashMap是线程不安全的，有可能会导致链表死循环的问题。JDK1.8之后加入了红黑树，且使用尾插法，避免了出现逆序以及死循环的问题。
void transfer(Entry[] newTable, boolean rehash) {//1.7中扩容后转换结点的代码。 int newCapacity = newTable.length; for (Entry<K,V> e : table) { while(null != e) { //1， 获取旧表的下一个元素 Entry<K,V> next = e.next;//<1> if (rehash) { e.hash = null == e.key ? 0 : hash(e.key); } int i = indexFor(e.hash, newCapacity); e.next = newTable[i]; newTable[i] = e; e = next; } } } 当两个线程都执行了扩容方法，线程A执行到<1>处后挂起 线程B执行完了这些代码后。线程A继续执行时就会出现循环链表的问题 -
扩容后数据存储位置的计算方法不同。在JDK1.7中直接使用hash值和需要扩容的二进制数进行&操作。（hash值&（length-1））。而JDK1.8直接判断Hash值的新增参与运算的位是0还是1直接计算出扩容后的存储方式。若新增参与运算的位=0，那么元素的扩容后的位置=原始位置。
若新增参与运算的位=1，那么元素的扩容后的位置=原始位置+扩容的大小。这里也就说明了为什么1.8中的散列表的长度一定是2的n次方大小。结点的hash直接和旧容量与操作。保留的就是最高位1或0。这样可以根据最高位0或者1 直接判断结点的去向。
3. 类图
继承了AbstractMap，实现了Map，Cloneable，Serializable接口。
4. 属性
// 底层存储的数组
transient Node<K, V>[] table;
//调用`#entrySet()` 方法后的缓存
transient Set<Map.Entry<K, V>> entrySet;
//键值的对数
transient int size;
//修改的次数
transient int modCount;
//阈值，当size超过threshold时会扩容。
int threshold;
//扩容因子
final float loadFactor;
// 数组默认容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认扩容因子 0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表转换成红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;
//红黑树转换成链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//红黑树允许树化的最少键值对数量，
static final int MIN_TREEIFY_CAPACITY = 64;
用于存储的是一个Node数组。其属性包括了哈希值，key键，value值，以及下一个节点。
table数组默认的容量是16。
5. 构造方法
一共有4种构造方法。注意以下用来的initialCapacity并不是table数组的长度。而是根据这个值来得到一个阈值，这个阈值一定是2的指数次。table长度在第一次put的时候，会根据阈值是否为0 来构建table数组的大小。若阈值大于0，则table数组的大小就是阈值的大小。否则默认大小16。
- 1.无参的构造方法 HashMap()
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
仅仅初始化了扩容因子位0.75.并没有对table数组的初始化。table数组是延迟初始化的，当第一个键值对添加的时候，才会启用resize（）方法进行初始化。
- 2.HashMap(int initialCapacity)
内部调用了另一个构造方法HashMap(int initialCapacity, float loadFactor)
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
- 3.HashMap(int initialCapacity, float loadFactor)
初始化了默认阈值和装载因子。
public HashMap(int initialCapacity, float loadFactor) {
// 校验 initialCapacity 参数
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 避免 initialCapacity 超过 MAXIMUM_CAPACITY（2的30次方）
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);
}
其中tableSizeFor（int cap）返回大于cap的最小2的N次方。
例如cap等于7，则返回8.若cap=126，则返回128。
- 4.HashMap(Map<? extends K, ? extends V> m)
将集合m添加到HashMap对象中
public HashMap(Map<? extends K, ? extends V> m) {
// 设置加载因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 批量添加到 table 中
putMapEntries(m, false);
}
批量添加的函数如下：
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
//若table为空
if (table == null) { // pre-size
//根据装载因子与集合m的大小，计算出最小的table大小。
float ft = ((float) s / loadFactor) + 1.0F;
int t = ((ft < (float) MAXIMUM_CAPACITY) ?
(int) ft : MAXIMUM_CAPACITY);
//若计算出来的t大于阈值，则计算新的阈值。
if (t > threshold)
threshold = tableSizeFor(t);
}
//若table不是空的 且s大于阈值，则扩容。
else if (s > threshold)
resize();
//将集合中逐个加入到HashMap中。
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
保证table容量足够大，若table还没有被初始化，则计算出最小容量的table，设置好阈值。此时还未被对table初始化，在后面的添加第一个键值对的时候才进行初始化。
将集合中逐个的添加到HashMao中。
6. 哈希函数
hash函数的计算是为了降低key键碰撞的概率，使得哈希值足够的离散。
代码如下：
static final int hash(Object key) {
int h;// h = key.hashCode()计算哈希值
//高16位与自身进行异或计算，保证计算出来的hash值更加的离散
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里进行了位运算和异或运算，效率高。自身与高16位进行异或是为了让hash值更加离散。
7. 添加元素
7.1 添加单个元素
外部调用使用put(K key, V value)方法，而真实的实现在putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict)。
代码如下：
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; // tables 数组
Node<K, V> p; //对应位置的Node节点
int n, i;//数组大小以及对应的table的位置。
//若table还没有被初始化，或者容量位0，则需要扩容。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 若对应位置的Node节点位空，则直接创建Node节点即可。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 如果对应位置的Node节点非空，则可能存在哈希冲突。
else {
Node<K, V> e; // key在对应HashMap对应的老节点
K k;
//若当前节点的hash值与key都与给定的参数相同，则记录这个节点。
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//若p节点的类型时红黑树节点，则直接添加到树中
else if (p instanceof TreeNode)
e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);//todo 了解如何在红黑树中添加
// 否则p的类型时Node节点，说明是一个链表，需要遍历查找。
else {
//遍历链表
for (int binCount = 0; ; ++binCount) {
//若遍历到表尾，则说明key在HashMap中不存在，则创建一个新的链表节点。
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//若链表的长度达到了红黑树转换阈值（8）的时候，则进行转换。链表转换成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);//todo 了解如何进行转换
break;
}
//若遍历到的节点，就是要找的，则使用该结点。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//若找到了对应的节点。
if (e != null) { // existing mapping for key
V oldValue = e.value;
//如果可以修改，则修改对应的value
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//节点被访问的回调。
afterNodeAccess(e);
//返回原来节点的值
return oldValue;
}
}
++modCount;//增加修改次数
if (++size > threshold)//修改容量，若大于阈值则扩容
resize();
afterNodeInsertion(evict);//添加节点后的回调
return null;
}
若table数组容量为0，或者未被初始化，则调用resize（）进行扩容。
找到要插入的那一个数组位置节点。
-
如果为空，则直接创建一个新的Node节点放入table数组中。
-
若不为空，则判断该节点属于什么类型，根据不同的节点类型，采取不同的插入方式。
1. 若是红黑树节点，则调用红黑树中的插入节点的方法。 2. 若是链表，则遍历链表，找到合适的位置加入。若加入后链表的长度等于8，则调用函数将链表转换成红黑树。 -
若发现节点已存在HashMap中，根据是否可以修改，将其value进行修改，调用节点被访问的回调函数，这里是一个空实现，相当于是一个模版。可供子类进行扩展。返回老值。
-
增加修改次数，修改容量。若容量大于阈值，则扩容。调用添加节点后的回调函数，同样是一个空实现。
-
返回null因为老值不存在
7.2 批量添加
添加多个元素到HashMap中
提供给外部调用的是putAll(Map<? extends K, ? extends V> m)，真正的实现是putMapEntries(m, true)，代码如下：
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
//若table为空
if (table == null) { // pre-size
//根据装载因子与集合m的大小，计算出最小的table大小。
float ft = ((float) s / loadFactor) + 1.0F;
int t = ((ft < (float) MAXIMUM_CAPACITY) ?
(int) ft : MAXIMUM_CAPACITY);
//若计算出来的t大于阈值，则计算新的阈值。
if (t > threshold)
threshold = tableSizeFor(t);
}
//若table不是空的 且s大于阈值，则扩容。
else if (s > threshold)
resize();
//将集合中逐个加入到HashMap中。
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
简单来说就是有了合适的table数组，然后遍历集合m中的元素，逐个的加入到table数组中，添加的方式是单个元素的添加方式。
7.3没有才添加
若map中已存在key-value键值对，不对其进行添加
public V putIfAbsent(K key, V value) {
return putVal(hash(key), key, value, true, true);
}
8. 删除元素
HashMap暂时不支持移除多个元素，只有移除单个元素。
供给外部使用的函数是remove(Object key)，根据键key来移除元素。返回value。内部是调用removeNode(int hash, Object key, Object value,boolean matchValue, boolean movable)来实现。
方法如下：
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;// table 数组
Node<K, V> p;// hash对应table数组中的p节点
int n, index;
// 查找 hash 对应table位置的p节点。
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;
// 若p节点就是要找的节点，则将其赋值给node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
// 若p节点不是要找的节点，则遍历p节点之后的节点。
else if ((e = p.next) != null) {
// 若p节点是红黑树节点，则直接使用红黑树中的查找算法 查找到需要的节点，并赋值给node
if (p instanceof TreeNode)
node = ((TreeNode<K, V>) p).getTreeNode(hash, key);//todo 了解查找节点的方法
// 若不是 则说明是链表节点。遍历链表节点。直到找到需要的节点，赋值给node
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);
}
}
// 若找到node节点，则将其移除
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 若node节点是红黑树节点，则调用红黑树中的删除节点的方法
if (node instanceof TreeNode)
((TreeNode<K, V>) node).removeTreeNode(this, tab, movable);//todo 了解删除节点的方法
// 若p节点等于node节点。说明找到的node节点是头结点。则直接将头结点删去
else if (node == p)
tab[index] = node.next;
// 否则 找到的就不是头结点，由于之前记录了node节点的前一个节点，则直接修改前一个节点的后继，即可删除node节点。
else
p.next = node.next;
// 增加修改次数
++modCount;
// 减少数量
--size;
// 移除node节点的回调函数
afterNodeRemoval(node);
return node;
}
}
// 查找不到返回null
return null;
}
流程很简单，查找key键所对应的Node节点。将Node节点删去。根据不同的节点类型，使用不同的删除方式。具体看上面的代码注释。
9. 树化
将hash值对于的table中的位置的链表转换为红黑树。代码如下
final void treeifyBin(Node<K, V>[] tab, int hash) {
int n, index;
Node<K, V> e;
// 若table为空或table容量小于最小树化的容量（64）则扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 若节点e不为空，遍历链表，逐个转换成红黑树节点。
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K, V> hd = null, tl = null;
do {
TreeNode<K, V> p = replacementTreeNode(e, null);//链表节点转换成红黑树节点
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
// 树化
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
转换要满足2个条件，1是table的容量要大于64，且链表的长度等于8.
对于小于64容量的table数组，不用树化，只要将其扩容即可。
若是大于64容量的数组，则逐个将链表节点转换成红黑树节点。将头点赋值给table数组。将其进行树的转换。
10. 扩容
HashMap是使用两倍扩容的。调用resize（）方法。同时resize（）方法也是table数组初始化的方法。代码如下：
final Node<K, V>[] resize() {
Node<K, V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;// 旧容量
int oldThr = threshold;// 旧阈值
int newCap, newThr = 0;// 新阈值与新容量
// 若旧容量大于0，说明table非空
if (oldCap > 0) {
// 若超过最大容量，则直接设置阈值为nteger.MAX_VALUE，不再允许扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 若旧容量大于等于默认值（16） 且 新的容量小于最大容量，则将阈值扩大两倍。
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 旧容量等于0，table位空，若旧阈值大于0，则将新的容量等于旧阈值大小。
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 若旧阈值为0，则将新的容量设置为默认大小（16），根据装载因子与默认容量的乘积计算出新的阈值。
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 若新的阈值等于0，则使用newCap * loadFactor 计算出新的阈值
if (newThr == 0) {
float ft = (float) newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
(int) ft : Integer.MAX_VALUE);
}
// 新阈值赋值给属性阈值。
threshold = newThr;
// 创建新的Node数组
@SuppressWarnings({"rawtypes", "unchecked"})
Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
// 赋值给属性table
table = newTab;
// 若原来的table数组不是空的，则需要进行转移。将老数组里的节点转移到新的table数组中。
if (oldTab != null) {
// 遍历老的table数组
for (int j = 0; j < oldCap; ++j) {
Node<K, V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;// 取出节点后，设置为空。
if (e.next == null)// e节点只有一个元素，则直接赋值给新的table
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) // 若e是红黑树节点，则通过红黑树分裂处理
((TreeNode<K, V>) e).split(this, newTab, j, oldCap);//todo 了解红黑树分裂处理
// 若e节点是一个链表，因为HashMap是两倍扩容的，所以原来位置的链表节点，会被分散到新的table中的两个位置。
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; // next指向下一个节点
// 通过 e.hash & oldCap 计算来分配 若结果为0，则分配到低位，结果为1，则分配到高位。
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) {// 设置低位到新的table数组的j位置上
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;// 设置高位到新的table数组的j+oldCap的位置上。
}
}
}
}
}
return newTab;
}
主要分成了两块内容，第一块是计算新的容量与扩容阈值，创建新的数组。第二块是将原数组拷贝到新的数组中。
- 第一部分：
- oldCap 大于 0 ，说明 table 非空，说明是两倍扩容。
当超过最大容量，则直接设置 threshold 阀值为 Integer.MAX_VALUE ，不再允许扩容。
因为容量是两倍扩容，所以新的阈值也是原来的两倍，直接用位运算效率更高。 - 当oldCap 等于 0 ，说明 table 为空，此时resize方法就是初始化table数组。
当oldThr 大于 0 ，则使用 oldThr 作为新的容量。
当oldThr 等于 0 ，则使用 DEFAULT_INITIAL_CAPACITY（16） 作为新的容量，然后计算新的 newThr 阀值。
- oldCap 大于 0 ，说明 table 非空，说明是两倍扩容。
- 第二部分：
分成了三种情况。
第一：e节点只有一个元素，直接赋值给table。
第二：若e节点是红黑树节点，则通过红黑树分裂处理。
第三：若e节点是链表节点，原来位置的链表节点分配到新数组的两个不同的位置。参考上面的不同点处提到的方法。
11. 查找
11.1 根据key键来查找
提供给外部调用的是get(Object key)，内部实际实现是getNode(int hash, Object key)
public V get(Object key) {
Node<K, V> e;
//根据key计算出hash值，调用getNode
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;
// 根据hash查找对应的table位置的第一个节点。即first节点。
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 若first节点的hash值与key值符合要求。则直接返回first节点。
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 若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);
}
}
// 没找到返回null
return null;
}
首先计算key对应的hash值。根据hash值可以确定table数组中的位置。此时找到该位置的第一个节点。
若该结点hash值与key值均符合要求，则返回节点。
若该结点的后继不为空。
则分为两种情况
- 若节点是红黑树节点，则调用红黑树中寻找node节点的方法。返回找到的节点。
- 若节点是链表节点。则遍历链表，返回结果。
没找到返回null。
11.2 根据value来查找。
public boolean containsValue(Object value) {
Node<K,V>[] tab; V v;
if ((tab = table) != null && size > 0) {
// 遍历 table 数组
for (Node<K,V> e : tab) {
// 处理链表或者红黑树节点
for (; e != null; e = e.next) {
// 如果值相等，则返回 true
if ((v = e.value) == value ||
(value != null && value.equals(v)))
return true;
}
}
}
// 找不到，返回 false
return false;
}
遍历table数组。遍历每个位置的节点。。如果值相等则返回true。没找到则返回false。根据值来比较是比较花费时间的。
11.3 getOrDefault
key不存在map中返回defaultValue，否则返回key对应的value
@Override
public V getOrDefault(Object key, V defaultValue) {
Node<K, V> e;
return (e = getNode(hash(key), key)) == null ? defaultValue : e.value;
}
12.清空
只要将table数组的没一位置为null 结点就由gc来帮忙回收
public void clear() {
Node<K, V>[] tab;
modCount++;
if ((tab = table) != null && size > 0) {
size = 0;
for (int i = 0; i < tab.length; ++i)
tab[i] = null;
}
}
13.用于子类实现
HashMap中很多方法出现了以下的三个空实现的方法，这是用于给子类去实现的方法。例如LinkedList去实现，在HashMap中添加了新的节点的后续操作。
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }