本文参考：https://blog.csdn.net/m0_37914588/article/details/82287191
HashMap
HashMap是基于哈希表实现的，每个元素都是一个键值对（key-value）。
HashMap在JDK1.7和JDK1.8中变化比较大，在JDK1.7中，HashMap的底层是采用以个Entry数组来存储数据，当发生hash冲突时，采用链地址法（即链表存储相同hashcode的元素）来解决。而在JDK1.8的HashMap使用一个Node数组来存储数据，但当存储元素的链表超过阈值之后，会将链表转换为红黑树，查询时间从O(n)转换为O(logn)。
接下来就让我们进入HashMap的源码吧（以下源码为1.8）！
首先我们来看看HashMap的属性
//数组的初始化容量-数值必须时2的幂
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量，可以使用一个带参数的构造函数来隐式的改变容量大小，但必须时2的幂且小于等于1<<30
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子初始值
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//使用树(而不是列表)来设置bin计数阈值。当向至少具有这么多节点的bin添加元素时，bin将转换为树。该值必须大于2，并且应该至少为8，以便与删除树时关于转换回普通桶的假设相匹配收缩。
static final int TREEIFY_THRESHOLD = 8;
//当桶（bucket）上的结点数小于该值是应当树转链表
static final int UNTREEIFY_THRESHOLD = 6;
//桶中结构转化为红黑树时对应的table的最小值
static final int MIN_TREEIFY_CAPACITY = 64;
//tables数组，在必要时会重新调整大小，但长度总是2的幂
transient Node<K,V>[] table;
//保存缓存的entrySet()。注意，使用了AbstractMap字段用于keySet()和values()。
transient Set<Map.Entry<K,V>> entrySet;
//在该map中映射的key-value对数量
transient int size;
//这个HashMap在结构上被修改的次数结构修改是指改变HashMap中映射的数量或修改其内部结构的次数(例如，rehash)。此字段用于使HashMap集合视图上的迭代器快速失效。(见ConcurrentModificationException)。
transient int modCount;
//要下一次调整大小的临界值（capacity * load factor）
int threshold;
//哈希表的加载因子
final float loadFactor;
//内部类Node，用于存放元素
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;
}
}
很多人不知道这个负载因子的变量是干什么用的，负载因子表示一个散列表的使用程度。有这样一个公式：initailCapacity*loadFactor=HashMap的容量。可以看出，当自定义容量不变的时候，负载因子越大，散列表在该容量下可以装填的元素越多，但是由此会导致链表更长，索引的效率降低。如果负载因子过小，则会导致散列表中的元素很少，对空间造成浪费。
接下来是HashMap的构造函数。
| 构造函数 |
|---|
HashMap() 构造一个空的 HashMap ，默认初始容量（16）和默认负载系数（0.75）。 |
HashMap(int initialCapacity) 构造一个空的 HashMap具有指定的初始容量和默认负载因子（0.75）。 |
HashMap(int initialCapacity, float loadFactor) 构造一个空的 HashMap具有指定的初始容量和负载因子。 |
HashMap(Map<? extends K,? extends V> m) 构造一个新的 HashMap与指定的相同的映射 Map 。 |
源码如下
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
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);
}
可以看出，HashMap提供了一个修改初始化容量和负载因子的构造方法，这样我们可以根据不同的使用环境，来决定我们HashMap的负载因子应该为多少。
接下来看看HashMap一些常用的方法。
| 返回类型 | 方法名（参数） |
|---|---|
void | clear() 从这张地图中删除所有的映射。 |
Object | clone() 返回此 HashMap实例的浅拷贝：键和值本身不被克隆。 |
boolean | containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。 |
void | forEach(BiConsumer<? super K,? super V> action) 对此映射中的每个条目执行给定的操作，直到所有条目都被处理或操作引发异常。 |
V | get(Object key) 返回到指定键所映射的值，或 |
boolean | isEmpty() 如果此地图不包含键值映射，则返回 true 。 |
Set<K> | keySet() 返回此地图中包含的键的 |
V | put(K key, V value) 将指定的值与此映射中的指定键相关联。 |
void | putAll(Map<? extends K,? extends V> m) 将指定地图的所有映射复制到此地图。 |
V | remove(Object key) 从该地图中删除指定键的映射（如果存在）。 |
boolean | remove(Object key, Object value) 仅当指定的密钥当前映射到指定的值时删除该条目。 |
V | replace(K key, V value) 只有当目标映射到某个值时，才能替换指定键的条目。 |
void | replaceAll(BiFunction<? super K,? super V,? extends V> function) 将每个条目的值替换为对该条目调用给定函数的结果，直到所有条目都被处理或该函数抛出异常。 |
int | size() 返回此地图中键值映射的数量。 |
我们通过put()和remove()两个最常用的方法来了解一下HashMap的增删过程。
在看这两个方法的源码之前，我们需要先来看看HashMap是如何计算哈希值的。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
put()方法
public V put(K key, V value) {
//四个参数，第一个hash值，第四个参数表示如果该key存在值，如果为null的话，则插入新的value，最后一个参数，在hashMap中没有用，可以不用管，使用默认的即可*
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab 哈希数组，p 该哈希桶的首节点，n hashMap的长度，i 计算出的数组下标
Node<K,V>[] tab; Node<K,V> p; int n, i;
//获取长度并进行扩容，使用的是懒加载，table一开始是没有加载的，等put后才开始加载
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果计算出的该哈希桶的位置没有值，则把新插入的key-value放到此处，此处就算没有插入成功，也就是发生哈希冲突时也会把哈希桶的首节点赋予p
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//发生哈希冲突的几种情况
else {
// e 临时节点的作用， k 存放该当前节点的key
Node<K,V> e; K k;
//第一种，插入的key-value的hash值，key都与当前节点的相等，e = p，则表示为首节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//第二种，hash值不等于首节点，判断该p是否属于红黑树的节点
else if (p instanceof TreeNode)
//为红黑树的节点，则在红黑树中进行添加，如果该节点已经存在，则返回该节点（不为null），该值很重要，用来判断put操作是否成功，如果添加成功返回null
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//第三种，hash值不等于首节点，不为红黑树的节点，则为链表的节点
else {
//遍历该链表
for (int binCount = 0; ; ++binCount) {
//如果找到尾部，则表明添加的key-value没有重复，在尾部进行添加
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//判断是否要转换为红黑树结构
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//如果链表中有重复的key，e则为当前重复的节点，结束循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//有重复的key，则用待插入值进行覆盖，返回旧值。
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//到了此步骤，则表明待插入的key-value是没有key的重复，因为插入成功e节点的值为null
//修改次数+1
++modCount;
//实际长度+1，判断是否大于临界值，大于则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
//添加成功
return null;
}
插入过程可以总结为一下几个步骤：
- 计算索引
- 检查是否hash冲突，不发生则直接插入
- 发生hash冲突后，判断插入方式，是链表插入还是红黑树插入
- 如果key重复，覆盖值
- 计算容量，是否进行扩容
HashMap计算索引的方式为：hash&（length-1)。
HashMap的扩容机制
final Node<K,V>[] resize() {
//把没插入之前的哈希数组做oldTal
Node<K,V>[] oldTab = table;
//old的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//old的临界值
int oldThr = threshold;
//初始化new的长度和临界值
int newCap, newThr = 0;
//oldCap > 0也就是说不是首次初始化，因为hashMap用的是懒加载
if (oldCap > 0) {
//大于最大值
if (oldCap >= MAXIMUM_CAPACITY) {
//临界值为整数的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
//标记##，其它情况，扩容两倍，并且扩容后的长度要小于最大值，old长度也要大于16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//临界值也扩容为old的临界值2倍
newThr = oldThr << 1;
}
//如果oldCap<0，但是已经初始化了，像把元素删除完之后的情况，那么它的临界值肯定还存在，如果是首次初始化，它的临界值则为0
else if (oldThr > 0)
newCap = oldThr;
//首次初始化，给与默认的值
else {
newCap = DEFAULT_INITIAL_CAPACITY;
//临界值等于容量*加载因子
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//此处的if为上面标记##的补充，也就是初始化时容量小于默认值16的，此时newThr没有赋值
if (newThr == 0) {
//new的临界值
float ft = (float)newCap * loadFactor;
//判断是否new容量是否大于最大值，临界值是否大于最大值
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;
//此处自然是把old中的元素，遍历到new中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
//临时变量
Node<K,V> e;
//当前哈希桶的位置值不为null，也就是数组下标处有值，因为有值表示可能会发生冲突
if ((e = oldTab[j]) != null) {
//把已经赋值之后的变量置位null，当然是为了好回收，释放内存
oldTab[j] = null;
//如果下标处的节点没有下一个元素
if (e.next == null)
//把该变量的值存入newCap中，e.hash & (newCap - 1)并不等于j
newTab[e.hash & (newCap - 1)] = e;
//该节点为红黑树结构，也就是存在哈希冲突，该哈希桶中有多个元素
else if (e instanceof TreeNode)
//把此树进行转移到newCap中
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
//此处表示为链表结构，同样把链表转移到newCap中，就是把链表遍历后，把值转过去，在置位null
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;
}
}
}
}
}
//返回扩容后的hashMap
return newTab;
}
可能源码看起来很吃力，但是耐心看下去就会发现其实也没有那么难。在这么长的代码里，我们其实需要关注的就是HashMap具体的扩容方式：newThr = oldThr << 1，也就是将原来的容量乘2。那么为什么偏偏是乘2呢？
乘2可以保证扩容后的容量为偶数，且方便于扩容后重新分桶的操作。上边讲过HashMap计算索引的方式是hash&(length-1)。如果length为奇数，就会导致length-1转换为二进制后末位为0，从而使得奇数索引没有用到，浪费了一半的内存空间。
那么它又是如何方便分桶的呢？假设我们桶的长度为4，扩容后为8。那么我们进行重新分桶时，原先桶0的元素只会分配到新的桶0和桶4，原桶1只会分配到新的桶1和桶5，以此类推。减少了重新分桶的hash冲突，肯定方便重新分桶呀。
扩容的时机也是一个知识点。什么时候进行扩容呢，HashMap中规定了一个阈值（阈值=容量*负载因子，初始阈值为16*0.75=12），当HashMap中存储的元素超过这个阈值时，HashMap就会采取一个扩容操作。
remove()
public V remove(Object key) {
//临时变量
Node<K,V> e;
//调用removeNode(hash(key), key, null, false, true)进行删除，第三个value为null，表示，把key的节点直接都删除了，不需要用到值，如果设为值，则还需要去进行查找操作
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
//第一参数为哈希值，第二个为key，第三个value，第四个为是为true的话，则表示删除它key对应的value，不删除key,第四个如果为false，则表示删除后，不移动节点
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
//tab 哈希数组，p 数组下标的节点，n 长度，index 当前数组下标
Node<K,V>[] tab; Node<K,V> p; int n, index;
//哈希数组不为null，且长度大于0，然后获得到要删除key的节点所在是数组下标位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
//nodee 存储要删除的节点，e 临时变量，k 当前节点的key，v 当前节点的value
Node<K,V> node = null, e; K k; V v;
//如果数组下标的节点正好是要删除的节点，把值赋给临时变量node
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不再是数组下标的节点，而是要删除结点的上一个结点**/
p = e;
} while ((e = e.next) != null);
}
}
//找到要删除的节点后，判断!matchValue，我们正常的remove删除，!matchValue都为true
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;
//此方法在hashMap中是为了让子类去实现，主要是对删除结点后的链表关系进行处理
afterNodeRemoval(node);
//返回删除的节点
return node;
}
}
//返回null则表示没有该节点，删除失败
return null;
}
remove()的过程其实与其他容器的差不多，就是寻址、删除。在这里就不多讲。
链表转红黑树的时机
链表转红黑树的时机由两个变量决定TREEIFY_THRESHOLD（默认为8）和MIN_TREEIFY_CAPACITY（默认为64）当HashMap中元素的个数小于MIN_TREEIFY_CAPACITY时，HashMap优先采用扩容的方式，而不是采用树化。当元素个数超过了6MIN_TREEIFY_CAPACITY的值后，我们通过TREEIFY_THRESHOLD来决定是否树化，当一个链表的长度超过TREEIFY_THRESHOLD后，就会将链表转化为红黑树。
HashMap的特点
- HashMap的key不可重复，key和value允许为null
- HashMap是非线程安全的，只能在单线程的环境下使用，多线程环境需要外部加锁
扫一扫
3161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
