个人看源码的笔记记录，基于JDK8。
数据结构图：
一、HashMap的成员变量
关注一下成员变量Node<K,V>[] table 即可，HashMap就是用Node数组来存取数据的。Node是HashMap的静态内部类。
//table数组默认初始化容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//table数组最大容量2^ 30 次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子默认值0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树形阈值：JDK 1.8 新增的，当使用 树 而不是 链表 作为桶的数据结构时使用
static final int TREEIFY_THRESHOLD = 8;
//非树形阈值：也是 1.8 新增的，扩容时分裂一个树形桶的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//树形最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 实际存放数据的成员变量table，就是一个Node数组，即HashMap就是用Node数组来存取数据的。
* HashMap数据结构=数组+单链表(链表长度超过8变成二叉树),Node如何形成单链表见后面分析
*/
transient Node<K,V>[] table;
//缓存的 <K,V>键值对 集合
transient Set<Map.Entry<K,V>> entrySet;
//当前存储的键值对数量
transient int size;
/**
* HashMap改变的次数
* HashMap非线程安全，在对HashMap进行迭代时，如果期间其他线程的参与导致HashMap的结构发生变化（比如put，remove等操作），会抛出异常ConcurrentModificationException
*/
transient int modCount;
/**
* 阈值，(capacity * load factor)，size > threshold时resize(扩容)
* 若table数组未初始化，threshold = table数组默认长度 = 0 (table数组初始化是在第一次put()时，HashMap构造函数中并没有初始化table数组，put()方法会对threshold重新计算)
*/
int threshold;
//负载因子，主要用来计算threshold值的
final float loadFactor;二、HashMap的静态内部类Node
成员变量Node<K,V> next存储着下一个节点对象的引用，所以Node对象才能在内部形成桶式单链表结构（jdk8后，单链表长度超过8时会变成红黑树，以优化链表查询需遍历整个链表进行查询）。
//节点类：HashMap实际存放键值对数据的地方，实现了Map.Entry接口
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;//K的hash值，存储起来不用重复计算
final K key;//键
V value;//值
Node<K,V> next;//下一个节点对象的引用，所以Node对象才能在内部形成桶式单链表结构
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 ^ 值的hashcode
* 让值也参与Node的hashCode计算是因为key的hash冲突，即不同key的hashCode可能相同，这时候就需要引入value的hashCode来唯一确定Node对象
* 参考Object的“重写equals()方法也需要重写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;
}
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;
}
}三、HashMap的4个构造函数
//指定初始容量与负载因子构建HashMap
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;
//这里可发现，构造函数并没有直接初始化table数组，只是给阈值threshold赋值了（table数组初始化是在第一次put()时）
this.threshold = tableSizeFor(initialCapacity);
}
//指定初始容量
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);//负载因子默认0.75
}
//最常用的构造函数，只是指定了负载因子使用0.75，其他字段保持编译器赋予的默认值
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//用Map构造一个负载因子为0.75的新HashMap
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
//将Map中数据放入新构建的HashMap中
putMapEntries(m, false);
}HashMap(int initialCapacity, float loadFactor)的最后一行：this.threshold = tableSizeFor(initialCapacity);注意一下，初始化了threshold值，而没有初始化table数组 。
所有构造函数都没有初始化table数组，table数组初始化是在第一次put()时（懒加载思想吧：在真正用到的时候才会去初始化），第一次put()时也会给阈值threshold 重新赋值。
四、HashMap的成员变量threshold的初始化函数tableSizeFor
/**
* 返回一个比指定容量大且最接近的2的幂次方整数（HashMao要求容量必须为2的幂次方）
* 例如：cap=10，return 的就是2^4=16
*/
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;//位运算，无符号右移1位、再与右移前的值或运算一次
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}是一个十分巧妙的算法，使用位运算效率高，目的就是为了得到比指定容量大且最接近的2的幂次方整数，HashMap要求table数组大小必须为2的幂次方，至于为啥这样要求，有的说扩容时也使用2的幂次方可减少key的hash碰撞，了解不深。
五、构造函数HashMap(Map<? extends K, ? extends V> m)
//将Map中数据放入新的HashMap中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
//迭代Map
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
//调用HashMap.putVal()方法，将Map的key、value放入HashMap中
putVal(hash(key), key, value, false, evict);
}
}
}可发现最后调用的还是HashMap.putVal()方法，将Map的key、value放入新的HashMap中。
六、Node对象key的hash值计算函数
/**
* key的hash值计算：将传入键的 hashCode 进行无符号右移 16 位，然后进行按位异或，得到这个键的哈希值。
* 由于哈希表的容量都是 2 的 N 次方，在当前，元素的 hashCode() 在很多时候下低位是相同的，这将导致冲突（碰撞），因此 1.8 以后做了个移位操作：将元素的 hashCode() 和自己右移 16 位后的结果求异或。
* int 4字节 32 位，无符号右移 16 位相当于把高位的一半移到低位。即让高16位也参与key的hash值计算中。这样可以避免只靠低位数据来计算哈希时导致的冲突，计算结果由高低位结合决定，可以避免哈希值分布不均匀。
* HashMap中table下标的计算：
* table数组下标i = (table.length - 1) & key的hash值
* 假设table.length=2^4=16，分析后可发现，hash值只有低4位参与了下标计算。
* 这样做很容易产生碰撞。仅仅异或一下，既减少了系统的开销，也不会造成的因为高位没有参与下标的计算从而引起的碰撞
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}七、HashMap.put()
put()执行流程图：
源码：
//往HashMap put数据
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; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0) // 1.
//初始化table数组,通过resize()的方式
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) // 2.
//table数组下标i = (table数组length - 1) & key的hash值
tab[i] = newNode(hash, key, value, null);//tab[i]==null，当前位置为空，直接创建一个新Node对象赋予tab[i]
else {
//tab[i] != null，当前位置已有Node对象
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) // 3.
//key已存在，用新值覆盖旧值（赋值e.value = value是在后面进行的，这里只是将旧Node赋给新Node对象）
e = p;
else if (p instanceof TreeNode) // 4.
//key不存在且旧Node属于TreeNode类型，放入红黑树中
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//key不存在且旧Node不属于TreeNode类型，即链表类型
for (int binCount = 0; ; ++binCount) { // 5.
if ((e = p.next) == null) {
//旧Node 的next为空，即没有下一个元素
p.next = newNode(hash, key, value, null);//创建Node赋给旧Node的next属性
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st // 6.
//0-7,循环判断次数 >= 8，加上新加的Node即链表长度超过8时，将链表tab转换为二叉树
treeifyBin(tab, hash);
break;//结束循环
}
//旧Node 的next不为空
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) // 7.
//key已存在，退出循环
break;
/**
* 将旧Node 的next赋予旧Node，继续循环判断Node.next是否为空.
* 所以查找单链表中Node.next为空的节点需要遍历整个链表，当链表数据量变大时效率低下.
* jdk1.8前HashMap数据结构=数组+单链表
* jdk1.8后HashMap数据结构=数组+单链表(链表长度超过8转换为二叉树)，引入二叉树加快Node.next为空节点的查询(只需遍历一半的节点)
*/
p = e;
}
}
if (e != null) { // existing mapping for key // 8.
//新Node不为空
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
//给新Node赋值value
e.value = value;
afterNodeAccess(e);
return oldValue;//返回旧值，函数结束
}
}
//tab[i]==null,创建新Node对象赋予tab[i]后
++modCount;//每次修改HashMap数据结构modCount自增，例如：新增、删除
if (++size > threshold) // 9.
//当前存储的键值对数量>=阈值，执行扩容
resize();
afterNodeInsertion(evict);
return null;
}1. 判断当前桶是否为空，空的就需要初始化（resize 中会判断是否进行初始化）。
2. 根据当前 key 的 hashcode 定位到具体的桶中并判断是否为空，为空表明没有 Hash 冲突就直接在当前位置创建一个新桶即可。
3. 如果当前桶有值（ Hash 冲突），那么就要比较当前桶中的 key、key 的 hashcode 与写入的 key 是否相等，相等就赋值给 e,在第 8 步的时候会统一进行赋值及返回。
4. 如果当前桶为红黑树，那就要按照红黑树的方式写入数据。
5. 如果是个链表，就需要将当前的 key、value 封装成一个新节点写入到当前桶的后面（形成链表）。
6. 接着判断当前链表的大小是否大于预设的阈值，大于时就要转换为红黑树。
7. 如果在遍历过程中找到 key 相同时直接退出遍历。
8. 如果 e != null 就相当于存在相同的 key,那就需要将值覆盖。
9. 最后判断是否需要进行扩容。
put()对象时，newNode()创建新节点代码：
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}很易懂，就是直接去new Node。
八、HashMap.resize()
//扩容。table数组初始化也是通过resize()执行的
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//记录旧table
int oldCap = (oldTab == null) ? 0 : oldTab.length;//旧容量
int oldThr = threshold;//旧阈值
int newCap, newThr = 0;//新容量、新阈值初始化0
if (oldCap > 0) {
//旧容量 > 0，即已初始化过
if (oldCap >= MAXIMUM_CAPACITY) {
//旧容量 >= 最大容量限制，阈值赋值Integer.MAX_VALUE，这样以后就不会自动扩容了
threshold = Integer.MAX_VALUE;
return oldTab;//返回旧数组
}
//新容量=旧容量*2，位运算效率高
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新容量没有达到最大容量限制且旧容量>=16，新阈值=旧阈值*2
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
//新容量=旧阈值。旧容量<=0(table未初始化)且旧阈值>0(构造函数中：this.threshold = tableSizeFor(initialCapacity)).
newCap = oldThr;
else { // zero initial threshold signifies using defaults
//旧容量<=0(table未初始化)且旧阈值<=0。HashMap()无参构造函数：oldTab(table)表为空，oldCap=0，oldThr=0。
newCap = DEFAULT_INITIAL_CAPACITY;//新容量初始化为16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//新阈值=16*0.75=12
}
//新阈值=0
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数组出来
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;//新数组赋予对象当前table
//旧数组不为空时
if (oldTab != null) {
//将旧数组中元素reHash到新数组中
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;
//节点是TreeNode，使用红黑树的rehash操作
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//节点是链表类型，使用链表的rehash
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;//返回新数组
}扩容时链表的resize可参照下图，来源（侵权删）：https://www.jianshu.com/p/ee0de4c99f87
重新计算容量，计算出所需容器的大小之后重新定义一个新的容器，将原来容器中的元素放入其中。
什么时候扩容：通过HashMap源码可以看到是在put操作时，即向容器中添加元素时，当前容器中元素的个数达到阈值（当前数组长度乘以加载因子的值）的时候，就会触发扩容了。
九、HashMap.get()
public V get(Object key) {
Node<K,V> e;
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;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
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;
}看懂了put()方法，再来看get()方法就比较容易理解了：
1. 将 key hash 之后定位到桶的位置；如果桶为空直接返回 null 。
2. 如果桶不为空，判断桶的第一个位置(有可能是链表、红黑树)的 key 是否为查询的 key，是就直接返回 value。
3. 如果第一个不匹配，则判断第一个key的类型是否为红黑树节点。
4. 红黑树就按照树的查找方式返回值。
5. 不然就按照链表的方式遍历匹配返回值。
606
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
