当我们使用一个HashMap做插入操作时。put方法内部都做了什么呢？
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
map.put("key1", "value1");
}
put 方法
源码
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
如果插入的key已经存在，则会将value更新。
方法直接调用了putVal来执行，可以看到第一个参数是hash()方法的返回值。
hash方法
源码
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
key 是 Map 的 key 值，
h 是 key 的 Hash 码，
hashCode() 是获取 key 的 Hash 码，底层调用 native 本地方法库获取
^ 异或 不同取 1 相同取 0
>>> 无符号右移16位
首先判断 key 是否为 null ，
如果为 null 返回：0；
如果不为 null 返回：h 异或 h 无符号右移16位的结果
putVal 方法
阅读源码过程中发现出现很多将赋值表达式写在if条件或者for条件中，虽然追求了代码的简洁，但也一定程度的降低了可读性。
源码，和我添加的注释
/**
* Implements Map.put and related methods.
*
* @param hash hash for key 键的hash运算结果
* @param key the key 键
* @param value the value to put 值
* @param onlyIfAbsent if true, don't change existing value 是否允许更新操作
* 如果是true则不修改已经存在的value，这个参数的使用可以看一下putIfAbsent方法，相当于是不允许更新操作
* @param evict if false, the table is in creation mode. 子类钩子函数使用此参数
* @return previous value, or null if none 返回原值，没有原值返回null
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
// 数组，即哈希表。也就是说HashMap是通过一个Node数组来保存链表的头节点
Node<K,V>[] tab;
// p 是哈希表中的一个元素，通过hash值和最大下标值进行与运算获取的
Node<K,V> p;
// n 是哈希表的长度，i 是哈希表的最大下标值
int n, i;
// 判断哈希表是否为空，或者哈希表长度为零，这里意图是令哈希表懒加载，只有在第一次进行put操作时才初始化哈希表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length; // 通过resize方法初始化哈希表
// ---------- 以下开始着手插入操作 ----------
// 判断哈希表中的元素是否为null，意图是如果通过哈希值算出来的下标对应的数组元素是null，说明当前链表中没有元素，可以直接新建节点存入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); // 新建一个Node节点直接复制到哈希表中。
else {
// 临时节点
Node<K,V> e;
// k是 哈希表找到的头元素Node的 key值
K k;
// 判断头节点的 key 和 新插入的key是否相同，简化操作
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 判断头节点是否为树节点，如果是树节点，则需要使用树结点的添加元素方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else { // 否则最终会以普通节点的方式插入一个Node
// 遍历链表 binCount是遍历次数，即链表长度
for (int binCount = 0; ; ++binCount) {
// e = p.next 当前e是p的下一个节点
// 判断p的下一个节点是否为null
if ((e = p.next) == null) {
// 如果遍历到最后一个节点都没有找到key相同的节点，则会新增一个节点链接到最后一个元素
p.next = newNode(hash, key, value, null);
// 判断链表长度是否超过 树化阈值，TREEIFY_THRESHOLD这个阈值是链表转换成红黑树的阈值
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 将链表转换成红黑树
treeifyBin(tab, hash);
// 循环从这里跳出，表示：待插入键值不存在于集合中，此时已经将其存放在链表最后一个，e 目前为null
break;
}
// 判断当前节点的 key 是否与传入的 key 一致
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
// 循环从这里跳出，表示：待插入键值已经存在，此时e持有这个已经存在的节点（不是null），待后续处理
break;
// 令p是自己的下一个节点，以便下一次遍历操作
p = e;
}
}
// 判断e是否为null，实际意义：判断待插入的键值是否存在（如果e == null不存在，e != null 已存在），相当于是更新操作
if (e != null) { // existing mapping for key -- 这句英文是源码的注释，意思是 map中存在key
V oldValue = e.value; // 获取获取原键值对的旧值
// 判断旧值是否允许更新，putIfAbsent方法传入的onlyIfAbsent为true不允许更新已存在的键值，但如果原值是null仍然可以更新
if (!onlyIfAbsent || oldValue == null)
e.value = value; // 更新
// 钩子函数 子类 LinkedHashMap 重写此类，HashMap中此方法无任何操作
afterNodeAccess(e);
// 将旧值返回，至此更新操作执行完毕
return oldValue;
}
}
// 用于迭代器的计算
++modCount;
// 如果节点个数超过阈值
if (++size > threshold)
// 进行扩容操作
resize();
// 钩子函数 子类 LinkedHashMap 重写此类，HashMap中此方法无任何操作
afterNodeInsertion(evict);
// 新增节点 返回null
return null;
}
首先，Map集合是懒加载，需要检查集合是否初始化。
然后，根据哈希值获取哈希表中对应的头节点。如果头节点是空，则新建节点放入头节点。
否则如果key与头节点的key一致，则获取头节点等待处理
否则如果头节点的类型是树节点，说明此链表已经树化（treeifyBin）处理，则使用putTreeVal方法进行插入操作
否则开始遍历链表，如果待插入的key不存在于链表中，则最后通过尾插法将新键值保存
否则获取存在的节点等待处理。
最后，如果是更新节点，则返回旧值
否则增加节点总个数（size），并判断size是否超过阈值（threshold）如果超过阈值则进行扩容
关键字： 懒加载，链表转树，尾插法，扩容
resize 方法
resize方法在 putVal方法中出现过两次，第一次是map的懒加载处理，第二次是新增节点后判断是否需要扩容。
源码
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
* 大意是方法用于初始化和双倍扩容哈希表。初始化使用threshold作为初始容量；扩容后原链表要么在原哈希表的索引位，要么以2次幂偏移。
* @return the table
*/
final Node<K,V>[] resize() {
// 获取旧哈希表
Node<K,V>[] oldTab = table;
// 获取原表容量 如果原表为空（未初始化）容量为0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 原表扩容阈值
int oldThr = threshold;
// 新表容量，阈值
int newCap, newThr = 0;
if (oldCap > 0) { // 原表容量是否大于0
if (oldCap >= MAXIMUM_CAPACITY) { // 判断原表容量是否大于等于最大容量（1 << 30）
threshold = Integer.MAX_VALUE // 已经超过最大容量，则将扩容阈值调整到整型最大值
return oldTab; // 不扩容，直接返回原表
}
// 否则判断新表容量是否小于最大容量并且原表容量是否大于默认初始化容量16（1 << 4）
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
// 如果oldThr>0说明HashMap在初始化的时候设置了初始容量（调用了new HashMap(int cap)）
// 此时的oldThr是通过初始容量计算得来的，详见tableSizeFor(initialCapacity)
// oldThr是比初始容量大的最小的2次幂（初始容量是10，则oldthr是16；初始容量是17，则oldthr是32）
newCap = oldThr; // 将新表容量设置为初始容量的扩容阈值
else { // zero initial threshold signifies using defaults -- 未设置初始容量，那么oldthr就是0，则使用默认初始容量
newCap = DEFAULT_INITIAL_CAPACITY; // 新表容量为默认初始容量
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); // 新表扩容阈值为默认负载因子（0.75）* 默认初始容量
}
// 新表扩容阈值为0时
if (newThr == 0) {
// 获取通过负载因子和新表容量计算的扩容阈值
float ft = (float)newCap * loadFactor;
// 当新表容量小于最大容量 且 ft小于最大容量时 新表扩容阈值为ft 否则为整型最大值
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;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
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;
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;
}
分为两部分
1.计算新表容量和扩容阈值（threshold）
2.转移旧表内容至新表
如果主动设置了初始容量，那么首次初始化哈希表的时候，哈希表的容量是大于主动设置容量的最小2次幂。
可以观察下面源码，例：initialCapacity是10，threshold是16，哈希表初始化后容量不是10而是16
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);
}
/**
* Returns a power of two size for the given target capacity.
* 通过给定的目标容量返回一个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;
}
newNode 方法
newNode方法在putVal中也出现过两次
看方法的名字即可知道是新建一个Node对象，Node类是HashMap类中的内部类
源码
// Create a regular (non-tree) node
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
/**
* Basic hash bin node, used for most entries. (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
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;
}
// ========== 省略源码 ==========
}
putTreeVal 方法
此方法是HashMap内部类TreeNode的方法
源码这里就不占用篇幅来贴出了，因为其中更多的是涉及算法层面的逻辑。
方法注释（Tree version of putVal.）也说明了此方法是树版本的putVal，即用于向红黑树添加一个节点。
内容是对红黑树遍历然后比较相同节点后更新，或插入新节点，最后还需通过左旋右旋和变色操作保持红黑树的姿态。这里主要是涉及红黑树的原理。
讲回putTreeVal方法的目的就是向已经转换成红黑树的链表，添加一个新的节点。
使用红黑树的目的就是希望利用二分查找的思想加快查找效率，而红黑树既满足链表又满足二分查找的条件
treeifyBin 方法
将链表转换成红黑树，加快查找效率。
在putVal方法中触发的条件就是链表长度超过默认的8个（binCount >= TREEIFY_THRESHOLD - 1）。
这里源码也不做展示。
总结
当仔细研究HashMap的put方法后，实际对HashMap的原理已经有了基本认知。
描述HashMap的原理可以从数据结构的角度展开来说，这是因为HashMap作为容器存储数据，那么数据存储一定离不开数据结构。
首先，java8的HashMap需要的数据结构有三种（数组、链表和红黑树）。
数组，是哈希表来作为链表的索引。哈希表会在元素个数大于扩容阈值时引发扩容，扩容是以2次幂的规模来处理，哈希表只有在第一次put元素时才会创建，所以HashMap是懒加载的。
链表，是真正保存数据的位置。因为哈希冲突的问题（由于哈希表的容量是一定的，所以不同的key经过hash运算出来的索引可能会相同，这种情况是哈希冲突），所以需要一个链表来保存所有哈希冲突的键值。
红黑树，是用二分法来解决链表查询效率的，链表的升级形态。当链表长度达到8时，会在本次put方法中将链表转换成红黑树。
1571
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
