源码解析(按顺序读代码)
- 几个重要的默认常量
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
private static final long serialVersionUID = 362498820763181265L;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
static final int MAXIMUM_CAPACITY = 1 << 30;
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;
...DEFAULT_INITIAL_CAPACITY: 哈希表的数组初始化的默认大小为 1 左位移 4 位，即十进制数 16;
MAXIMUM_CAPACITY: 数组容量的最大值，2的30次幂;
DEFAULT_LOAD_FACTOR: 默认的扩容因子为0.75。这个数字一般不建议修改，参与扩容阈值的计算。
TREEIFY_THRESHOLD: 树化的阈值，默认为8;
UNTREEIFY_THRESHOLD: 树降级为链表的阈值，默认为6;
MIN_TREEIFY_CAPACITY: 树化的另一个参数，当哈希表的节点数（K-V个数）总量达到默认值64以后，才回去考虑树化，即满足这个条件以后单个链表达到8就会树化;
- 几个重要的默认成员变量
/* ---------------- Fields -------------- */
transient Node<K,V>[] table;
transient Set<Map.Entry<K,V>> entrySet;
transient int size;
transient int modCount;
int threshold;
final float loadFactor;对上述成员变量的一些简单说明：
table，指的就是hash表；
size，表示当前hash表中的元素个数；
modCount，表示hash表结构修改的次数，新加或者删除元素都会计算，但是替换不会；
threshold，扩容阈值，当hash表中的元素个数超过这个值的时候会触发扩容，计算的方法是 CAPACITY * LOAD_FACTOR
loadFactor，扩容因子（参与扩容阈值的计算，默认值是专门计算好的，最好不要改动）
- 链表的节点
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;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
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;
}
}这个Node实际上就是存储键值对的容器，以链表或者红黑树这样的数据结构存储。首先解释一下这个静态内部类的成员属性。hash，表示一个hash值，这里面会对key值做hash运算（扰动函数，下面hash方法会讲），将得到的值赋值给这个成员变量；key，用户数据的键的值（不必多言）；value，用户数据的值的值；next，节点指向下一个节点的地址值。可以通过链表来理解：当next==null的时候表示当前节点是链表的最后一个节点。树同理。方法用到的时候做解释。
- hash的扰动函数
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}根据以上的方法可以知道
- 键的值为null，数据存放的位置是数组下标为0的链表（或者树）；
- 键的值不为null，h是key的 hashCode，方法的返回值是当前hash值（32位）与自身高16位的^运算的结果，一张图解释一下这个扰动函数
00000000 00000000 00000000 00000101 // h ^ 00000000 00000000 00000000 00000000 // h >>> 16 -> 00000000 00000000 00000000 00000101 // hash = h ^ (h >>> 16) 00000000 11111111 00000000 00000101 // h ^ 00000000 00000000 00000000 11111111 // h >>> 16 -> 00000000 11111111 00000000 11111010 // hash = h ^ (h >>> 16) 解释 异或 ^ 运算： 参加运算的两个数据，按二进制位进行“异或”运算。 运算规则：0^0=0； 0^1=1； 1^0=1； 1^1=0； 即：参加运算的两个对象，如果两个相应位为“异”（值不同），则该位结果为1，否则为0。而这个计算得到的hashcode,将会参与路由地址运算，下面遇到会讲。
- 初始化数组容量的大小运算
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;
}hashmap保证初始化的容量一定是2的次幂，并且一定是大于等于 cap （tableSizeFor(int cap)...）的最小二次幂，为什么？解读一下上述代码的执行原理
假设 cap = 7
n = 7 -1 ->6
n= 6 | 6>>>1
0000 0000 0000 0110 6
| 0000 0000 0000 0011 6>>>1
= 0000 0000 0000 0111 7
n=7 | 7>>>1
0000 0000 0000 0111 7
| 0000 0000 0000 0011 7>>>1
= 0000 0000 0000 0111 7
...同理可以知道 最后计算得到的n必然是7
返回 如果 n<0 显然不满足，只有传入的cap值小于等于0的时候，返回1
否则 (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1
可以知道 最后返回的结果是 7+1 为 8
按位或运算符（|）
参加运算的两个对象，按二进制位进行“或”运算。
运算规则：0|0=0； 0|1=1； 1|0=1； 1|1=1；
即 ：参加运算的两个对象只要有一个为1，其值为1。至于为什么要cap-1然后或运算，假设cap的值为16 最后计算的n必然为31，返回的结果就是32。cap-1 保证得到的返回值一定是大于等于 cap （tableSizeFor(int cap)...）的最小二次幂。
- 构造器
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);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}首先对参数进行校验（pass），然后给成员属性赋值。根据上述对 tableSizeFor 这个方法的解读可以知道，初始化的size必然是大于等于传入参数的最小2次幂。hashmap也提供了参数为map的构造器。
接下来解读两个核心的方法（面试高频）
- put（注释说明）
/**
* 向hash表中添加元素的方法
* @param hash key 的 hash 值
* @param key 表示存储的 键
* @param value 表示存储的 值
* @param onlyIfAbsent 如果为 true 就不更新 value的值
* @param evict
* @return
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// tab表示hash表 p作为当前Node
// n用来传递hash表的长度 i用来传递数组的下标（路由寻址的结果）
Node<K,V>[] tab; Node<K,V> p; int n, i;
//延迟初始化
//重要：当new一个散列表并且没有给他put值的时候，它的容量为0，直达有数据进来才会初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果路由寻址的数组位置没有值，即当前数组下标的地址上没有存储元素，就直接将新的节点放置
//路由寻址：(capacity -1) & hashCode(key)
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
/**
* 接下来的情况就是 存放一个元素，并且产生了hash冲突，需要将这个元素放在某一条链表或者
* 某一棵树上
*/
//e:Node的临时元素
//k:key的临时元素
Node<K,V> e; K k;
//翻译：如果当前Node的key的hash值等同于传进来的，意思就是说传进来的key在散列表中已经存在，并且
//当前Node的key的hash值 和 key 相同 或者 （key不为空 并且等同于 当前的key）
//其实就是说 此时put的key在散列表中已经存在 e指向 p:当前的元素
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 {
//此时讨论新的节点进入链表存储
for (int binCount = 0; ; ++binCount) {
//e指向当前的节点的下一个地址值是null 插入新的数据 （尾插）
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//插到第八个的时候 binCount=7 的时候 树化链表并退出
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//e指向的节点不为null，e指向下一个节点
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//e!=null 找到了和当前key一致的数据，并进行替换，直接返回，走不到 ++modCount;
//意思1 替换 2 不会计数更改hash表结构
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//put操作会记一次 修改hash表结构
++modCount;
if (++size > threshold)
resize();
//afterNodeInsertion 空方法体
afterNodeInsertion(evict);
return null;
}解释一下路由寻址：（capacity-1）& hashCode(key) 目的是为了让数据更均匀地分布在数组上。由以上说明，在new出hash表的时候其实并没有进行初始化的操作，而在put第一个值的时候才会初始化。
通过扰动算法和key的值，求出hash，再通过路由寻址算法求得数组下标。目的是让数据更加均匀地分布在hash表上面，减少hash冲突。当hash表的数据大于64并且单个链表的数据量达到8的时候，会进行树化。
-
resize（注释说明）
/**
* 第一次 put 元素初始化 或 扩容算法
* Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
* table = newTab;
* 方法中的这两行代码说明 初始化的时候即第一次调用才resize()会给 table赋值对象，否则为null
* @return 返回一个扩容后的hash表
*/
final Node<K, V>[] resize() {
//将当前的hash表和容量，扩容阈值赋值
Node<K, V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
//新的容量，新的阈值初始化 0
int newCap, newThr = 0;
//如果oldCap = 0 （oldCap = (oldTab == null) ? 0 : oldTab.length）表示 oldTab == null，即此时hash表并没有经过初始化转到else
if (oldCap > 0) {
//否则，当hash表已经经过初始化后
//如果 容量大于 1<<<30 则将容量设置成Integer.MAX_VALUE
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果 2倍扩容后还是小于最大容量（这个基本满足），并且 扩容之前的容量大于等于16 ，阈值也变为原来阈值的2倍
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
//如果之前的容量=0 并且阈值大于0 将容量的大小设置成阈值的大小
newCap = oldThr;
else {
// zero initial threshold signifies using defaults
//官方的注释说明 初始化的容量为 16，阈值为 16*0.75 ==12
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
//初始化hash表对象，并给定初始化大小为扩容后的大小newCap
table = newTab;
if (oldTab != null) {
//当原来的hash表中有数据的时候，就需要将原来的数据重新存储到扩容后的hash表中，遍历
for (int j = 0; j < oldCap; ++j) {
//定义一个临时节点（指针对象）
Node<K, V> e;
//(e = oldTab[j]) != null 说明 第一个节点不是null
if ((e = oldTab[j]) != null) {
//置空交给jvm垃圾回收
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;
//newTab[j + oldCap] = hiHead;
//原来的数组下标+原来容量 就是新的数组下标
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;
}
由上面的代码可以看出，如果hash表中还没有数据，是不会初始化大小的，当第一次put数据，初始化默认值（在构造器没有给定大小的前提下）。
当满足扩容的条件的时候，会对容量进行2倍扩容，并且阈值也会跟着2倍扩容。数组上的第一个数据不为null的情况下会根据路由寻址算法再次算出新的数组下标。而后面的节点数据会在原有基础上加上原来数组的容量作为下标，或者下标不变。根据路由寻址算法可以知道最后几位的hash值是不变的，而被扩容后的路由寻址算法得到的值无非前面一位是1 和 0。
扫一扫
451
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
