一.写在最前
去年写的HashMap，自己的理解，结合一些文章，断断续续整理发布一版。
什么是bin桶？
其实呢，去看hashset底层，也是hashmap
* This map usually acts as a binned (bucketed) hash table, but
* when bins get too large, they are transformed into bins of
* TreeNodes, each structured similarly to those in
* java.util.TreeMap. Most methods try to use normal bins, but
* relay to TreeNode methods when applicable (simply by checking
* instanceof a node). 引入3个概念
值得注意的是 capacity 必须是2的幂次
1.操作系统的分页原版是2的倍数，如4K,8K等，故计算机申请内存多为2的幂次，这样可以减少内存碎片
2.方便与操作，2的幂次-1 换算成二进制全部是1
3.速度快
/**
* The default initial capacity - MUST be a power of two.
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* The bin count threshold for using a tree rather than list for a
* bin. Bins are converted to trees when adding an element to a
* bin with at least this many nodes. The value must be greater
* than 2 and should be at least 8 to mesh with assumptions in
* tree removal about conversion back to plain bins upon
* shrinkage.
*/
static final int TREEIFY_THRESHOLD = 8;注释中已经给了比较好的解释
* <p>An instance of <tt>HashMap</tt> has two parameters that affect its
* performance: <i>initial capacity</i> and <i>load factor</i>. The
* <i>capacity</i> is the number of buckets in the hash table, and the initial
* capacity is simply the capacity at the time the hash table is created. The
* <i>load factor</i> is a measure of how full the hash table is allowed to
* get before its capacity is automatically increased. When the number of
* entries in the hash table exceeds the product of the load factor and the
* current capacity, the hash table is <i>rehashed</i> (that is, internal data
* structures are rebuilt) so that the hash table has approximately twice the
* number of buckets.另外呢,如下3个概念需要了解一下
Collections.synchronizedMap fail-fast ConcurrentModificationException
二、HashMap架构组成
1. key是怎么做hash的
key 的 hash值的计算是通过hashCode()的高16位异或低16位实现的：(h = k.hashCode()) ^ (h >>> 16)
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}异或后 会提高hash的散列度 减少冲突
hash=(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16)
对于传入 原值1 key值 A1： 10010001 10010101 10110000 11110001
右移16位 B1： 00000000 00000000 10010001 10010101
A ^ B C1： 10010001 10010101 00100001 01100100
参考上一个 (p = tab[i = (n - 1) & hash])
假如数组大小 D： 00000000 00000001 00000000 00000000
n-1 得到 E： 00000000 00000000 11111111 11111111
原值1 与后 F： 00000000 00000000 00100001 01100100
异或后 G： 00000000 00000000 00100001 01100100
异或后 会提高hash的散列度 避免冲突2.如何找到在Node<K,V> table中的索引位置
n即是默认的16； hash即传过来的k的hash
上文已经提到2的幂次-1，低数据位全是1，做与运算会提高散列，减少冲突，是怎么做到的呢？
(p = tab[i = (n - 1) & hash]) == null如上代码在put / get 代码块中都有实现
//put函数代码块中
tab[i = (n - 1) & hash])
//get函数代码块中
tab[(n - 1) & hash]) 为什么说是2的幂次会提高散列度 n-1 后得到的结果都是1，作与运算
put方法中：此时的n 是16 (p = tab[i = (n - 1) & hash])
n=16 即 10000
n-1 的值15 A1： 0000 1111
对于任意数B1 0000 0001 -> 0000 0001 [和A作与]
对于任意数C1 0001 0000 -> 0000 0000 [和A作与]
如果n不是2的幂次，比如n是15
n=15 即 1111
n-1 的值为14 A2： 0000 1110
对于任意数B2 0000 0001 -> 0000 0000 [和A作与]
对于任意数C2 0001 0000 -> 0000 0000 [和A作与]3.HashMap 1.7 VS 1.8 设计图
3.1 JDK1.7 设计 图如下
实现方式 节点数>=8 节点数<=6
数组+单向链表 数组+单向链表 数组+单向链表
3.2 JDK1.8设计如下
实现方式 节点数>=8 节点数<=6
数组+单向链表+红黑树 数组+红黑树 数组+单向链表
可以看出,HashMap底层就是一个数组结构
数组中的每一项又是一个链表,当新建一个HashMap时,就会初始化一个数组.
存储数据的Node数组,长度是2的幂.
HashMap采用链表法解决冲突，每一个Node本质上是一个单向链表
HashMap底层存储的数据结构,是一个Node数组.Node类为元素维护了一个单向链表.
至此,HashMap存储的数据结构也就很清晰了:维护了一个数组,每个数组又维护了一个单向链表.之所以这么设计,考虑到遇到哈希冲突的时候,同index的value值就用单向链表来维护。与 JDK 1.7 的对比（Entry类），仅仅只是换了名字
三、HashMap源码分析
1. 静态常量 记住
//这两个是限定值 当节点数大于8时会转为红黑树存储
static final int TREEIFY_THRESHOLD = 8;
//当节点数小于6时会转为单向链表存储
static final int UNTREEIFY_THRESHOLD = 6;
//红黑树最小长度为 64
static final int MIN_TREEIFY_CAPACITY = 64;
//HashMap容量初始大小
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//HashMap容量极限
static final int MAXIMUM_CAPACITY = 1 << 30;
//负载因子默认大小
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//Node是Map.Entry接口的实现类
//在此存储数据的Node数组容量是2次幂
//每一个Node本质都是一个单向链表
transient Node<K,V>[] table;
//HashMap大小,它代表HashMap保存的键值对的多少
transient int size;
//HashMap被改变的次数
transient int modCount;
//下一次HashMap扩容的大小
int threshold;
//存储负载因子的常量
final float loadFactor;
2.Hashmap成员变量
public class HashMap<K, V> {
/**
* 分析的 `储存数据的数组`
*/
transient Node<K,V>[] table;
/**
* 用于 **entrySet()和values()**方法，返回一个迭代器遍历Map结构
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 整个hashmap 所包含的节点数
*/
transient int size;
/**
* hashmap 的结构修改次数，比如 Put，remove的次数,
* 和上面的 迭代器配合使用，在迭代过程中，如果其它线程更改了这个值，则会抛出 `ConcurrentModificationException`异常
*/
transient int modCount;
/**
* hashmap扩容的阈值，值为 loadFactor*table.length e.g: 0.75 * 16 = 12
* 也就是说默认是当数组大小超过 12时就会进行数组扩容
*/
int threshold;
/**
* 加载因子，默认值上图已经说明
*/
final float loadFactor;
}
3.Node类数据结构
四个成员变量， key, key的hash值, key对应的value,下一个节点的引用，其中链表的形成就是 next这个引用的作用
有2个比较重要的方法 hashcode() & equals
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
...
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
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的单向链表的实现 ，Node实现了 Map.Entry接口
//实现了Map.Entry接口
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;
}
//equals属性对比
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;
}
}4.TreeNode红黑树的实现 [此处暂时作为了解]
static final class TreeNode<K,V> extends LinkedHashMap.LinkedHashMapEntry<K,V> {
TreeNode<K,V> parent; // 红黑树的根节点
TreeNode<K,V> left; //左树
TreeNode<K,V> right; //右树
TreeNode<K,V> prev; // 上一个几点
boolean red; //是否是红树
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* 根节点的实现
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
...5.Hash的计算实现
//主要是将传入的参数key本身的hashCode与h无符号右移16位进行二进制异或运算得出一个新的hash值
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
6.HashMap putval实现
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}putVal实现
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//如果table为空或者长度为0，则resize() or 如果map是空的，则先开始初始化，table是map中用于存放索引的表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//确定插入table的位置，算法是(n - 1) & hash，在n为2的幂时，相当于取摸操作。
找到key值对应的槽并且是第一个，直接加入
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 如果走到else这一步，说明key索引到的数组位置上已经存在内容，即出现了碰撞
//在table的i位置发生碰撞，有两种情况，1、key值是一样的，替换value值，
//2、key值不一样的有两种处理方式：2.1、存储在i位置的链表；2.2、存储在红黑树中
else {
Node<K,V> e; K k;
//其中p已经在上面通过计算索引找到了，即发生碰撞那一个节点!!!
// 比较，如果该节点的hash和当前的hash相等，而且key也相等或者
// 在key不等于null的情况下key的内容也相等，则说明两个key是一样的，则将当前节点p用临时节点e保存
//第一个node的hash值即为要加入元素的hash !
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//2.2 如果当前节点p是（红黑）树类型的节点，则说明碰撞已经开始用树来处理
else if (p instanceof TreeNode)
// 其中this表示当前HashMap, tab为map中的数组
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//2.1
else {
//不是TreeNode,即为链表,遍历链表
for (int binCount = 0; ; ++binCount) {
///链表的尾端也没有找到key值相同的节点，则生成一个新的Node,
//并且判断链表的节点个数是不是到达转换成红黑树的上界达到，则转换成红黑树。
// +如果当前碰撞到的节点没有后续节点，则直接新建节点并追加
if ((e = p.next) == null) { // 如果p的next为空,将新的value值添加至链表后面
// 创建链表节点并插入尾部
p.next = newNode(hash, key, value, null);
// TREEIFY_THRESHOLD = 8 从0开始的，如果到了7则说明满8了，
// 这个时候就需要 重新确定是否是扩容还是转用红黑树了
超过了链表的设置长度8就转换成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
} // 找到了碰撞节点中，key完全相等的节点，则用新节点替换老节点 !!
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e; // 将 e 赋值给 p（p的下一个节点赋值给p），开启下一次循环.移动指针方便继续取 p.next
}
}
//e不等于null，则表示 key值相等，替换原来的value即可,这里不是表示 hash冲突,hash冲突链表的扩展已经在最后一个 else完成了
//如果e不为空就替换旧的oldValue值 此时的e是保存的被碰撞的那个节点，即老节点
if (e != null) { // existing mapping for key
V oldValue = e.value;
// onlyIfAbsent是方法的调用参数，表示是否替换已存在的值，
// 在默认的put方法中这个值是false，所以这里会用新值替换旧值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//替换新值后，回调该方法（子类可扩展）
afterNodeAccess(e);
// 此时直接返回，结束。
// 由于是替换 hashmap没有进行变更新操作[modCount不变]，且k-v数量也没变[size也没变]没必要再往下继续走了，直接返回
return oldValue;
}
}
// map变更性操作计数器 比如map结构化的变更像内容增减或者rehash，这将直接导致外部map的并发
// 迭代引起fail-fast问题，该值就是比较的基础
++modCount;
// size即map中包括k-v数量的多少 当map中的内容大小已经触及到扩容阈值时，则需要扩容了
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}对代码的解读大致如下
(1).判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；
(2).根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向(6)，如果table[i]不为空，转向(3)；
(3).判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向(4)，这里的相同指的是hashCode以及equals；
(4).判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向(5)；
(5).遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；
(6).插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。
注：hash 冲突发生的几种情况：
1.两节点key 值相同（hash值一定相同），导致冲突；
2.两节点key 值不同，由于 hash 函数的局限性导致hash 值相同，冲突；
3.两节点key 值不同，hash 值不同，但 hash 值对数组长度取模后相同，冲突；
7.HashMap get 实现
//这里直接调用getNode函数实现方法
public V get(Object key) {
Node<K,V> e;
//经过hash函数运算 获取key的hash值
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;
//判定三个条件 table不为Null & table的长度大于0 & table指定的索引值不为Null
/* first = tab[(n - 1) & hash] 通过 hash值算出key在数组中的 位置，取出该节点 */
/* 不为空，表示key在数组中存在，接下来开始遍历链表获取红黑树，找出具体位置 */
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判定 匹配hash值 & 匹配key值 成功则返回 该值
/* 如果链表或者红黑树的第一个节点 hash值，key相等，这个节点就是我们要找的，直接返回 */
if (first.hash == hash &&
((k = first.key) == key || (key != null && key.equals(k))))
return first;
//若 first节点的下一个节点不为Null
if ((e = first.next) != null) {
if (first instanceof TreeNode) //若first的类型为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;
}对get源码进行解读
1.判定三个条件 table不为Null & table的长度大于0 & table指定的索引值不为Null
2.判定 匹配hash值 & 匹配key值 成功则返回 该值
3.若 first节点的下一个节点不为Null
3.1 若first的类型为TreeNode 红黑树 通过红黑树查找匹配值 并返回查询值
3.2若上面判定不成功 则认为下一个节点为单向链表,通过循环匹配值
8.resize 方法 重点放到put get方法
final Node<K,V>[] resize() {
// 保存当前table /* 同样声明本地变量，得到原来的数组，提高性能 */
Node<K,V>[] oldTab = table;
// 保存当前table的容量 默认16
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 保存当前阈值 默认12
int oldThr = threshold;
// 初始化 新的 table容量和阈值
int newCap, newThr = 0;
/*
1. resize（）函数在size > threshold时被调用。oldCap大于 0 代表原来的 table 表非空，
oldCap 为原表的大小，oldThr（threshold） 为 oldCap × load_factor
*/
if (oldCap > 0) {
// 若旧table容量已超过最大容量1<<32，更新阈值为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
}
/*
2. resize（）函数在table为空被调用。oldCap 小于等于 0 且 oldThr 大于0，代表用户创建了一个 HashMap，但是使用的构造函数为
HashMap(int initialCapacity, float loadFactor) 或 HashMap(int initialCapacity)
或 HashMap(Map<? extends K, ? extends V> m)，导致 oldTab 为 null，oldCap 为0， oldThr 为用户指定的 HashMap的初始容量。
*/
else if (oldThr > 0) // initial capacity was placed in threshold
//当table没初始化时，threshold持有初始容量。还记得threshold = tableSizeFor(t)么;
newCap = oldThr;
/*
3. resize（）函数在table为空被调用。oldCap 小于等于 0 且 oldThr 等于0，
用户调用 HashMap()构造函数创建的 HashMap，所有值均采用默认值，oldTab（Table）表为空，oldCap为0，oldThr等于0，
*/
else { // zero initial threshold signifies using defaults
/* 第一次调用 resize方法，初始化数组长度，阈值，这里就对应我们前面成员变量的分析了：
* 阈值 = 加载因子 * 数组长度
* */
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 新阈值为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"})
// 初始化table 根据前面计算出来的新长度，声明一个新数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
/* 开始将旧数组的长度复制到新数组 */
if (oldTab != null) {
// 把 oldTab 中的节点 reHash 到 newTab 中去
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
/* 原数组的值先置换为null，帮助gc */
oldTab[j] = null;
// 若节点是单个节点，直接在 newTab 中进行重定位
/* 如果节点的next不为空（没有形成链表），直接复制到新数组 */
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;
// 将同一桶中的元素根据(e.hash & oldCap)是否为0进行分割（代码后有图解，可以回过头再来看），
分成两个不同的链表，完成rehash
do {
next = e.next;
// 根据算法 e.hash & oldCap 判断节点位置 rehash 后是否发生改变
//最高位==0，这是索引不变的链表。
// 原索引
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 原索引+oldCap
//最高位==1 （这是索引发生改变的链表）
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 原索引放到bucket里
if (loTail != null) { // 原bucket位置的尾指针不为空(即还有node)
loTail.next = null; // 链表最后得有个null
newTab[j] = loHead; // 链表头指针放在新桶的相同下标(j)处
}// 原索引+oldCap放到bucket里
if (hiTail != null) {
hiTail.next = null;
// rehash 后节点新的位置一定为原来基础上加上 oldCap，具体解释看下图
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
}
对resize方法进行解读
1.判定数组是否已达到极限大小，若判定成功将不再扩容，直接将老表返回
2.若新表大小(oldCap2)小于数组极限大小&老表大于等于数组初始化大小 判定成功则 旧数组大小oldThr 经二进制运算向左位移1个位置 即 oldThr2当作新数组的大小
2.1. 若[2]的判定不成功，则继续判定 oldThr （代表 老表的下一次扩容量）大于0，若判定成功 则将oldThr赋给newCap作为新表的容量
2.2 若 [2] 和[2.1]判定都失败,则走默认赋值 代表 表为初次创建
3.确定下一次表的扩容量, 将新表赋予当前表
4.通过for循环将老表中德值存入扩容后的新表中
4.1 获取旧表中指定索引下的Node对象 赋予e 并将旧表中的索引位置数据置空
4.2 若e的下面没有其他节点则将e直接赋到新表中的索引位置
4.3 若e的类型为TreeNode红黑树类型
4.3.1 分割树，将新表和旧表分割成两个树，并判断索引处节点的长度是否需要转换成红黑树放入新表存储
4.3.2 通过Do循环 不断获取新旧索引的节点
4.3.3 通过判定将旧数据和新数据存储到新表指定的位置
最后返回值为 扩容后的新表。9.treeifyBin
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//做判定 tab 为Null 或 tab的长度小于 红黑树最小容量
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//则通过扩容,扩容table数组大小
resize();
//做判定 若tab索引位置下数据不为空
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) //若头部节点为Null,则说明该树没有根节点
hd = p;
else {
p.prev = tl; //指向父节点
tl.next = p; //指向下一个节点
}
tl = p; //将当前节点设尾节点
} while ((e = e.next) != null); //若下一个不为Null,则继续遍历
//红黑树转换后,替代原位置上的单项链表
if ((tab[index] = hd) != null)
hd.treeify(tab); // 构建红黑树，以头部节点定为根节点
}
}
TreeNode<K,V> replacementTreeNode(Node<K,V> p, Node<K,V> next) {
return new TreeNode<>(p.hash, p.key, p.value, next);
}
四、Hashmap
1.怎么保证表的table数组的大小是2的幂次呢？这个方法的实现着实很赞
如个给定10，返回2的4次方16.
a |= b 等同于 a = a|b
/**
* Returns a power of two size for the given target capacity.
*/
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;
}2.HashMap的长度为什么是2的幂次
为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀，每个链表/红黑树长度大致相同。这个实现就是把数据存到哪个链表/红黑树中的算法。
这个算法应该如何设计呢？
我们首先可能会想到采用%取余的操作来实现。但是，重点来了：“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作（也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；）。” 并且采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。
3.当 TREEIFY_THRESHOLD>8 单个bin桶的组织形式 链表-->红黑树 ；当UNTREEIFY_THRESHOLD=6 时红黑树->链表
在链表中查找节点采用的是遍历的方式，所以一旦链表过长，查找性能就较慢，
这也是为什么jdk1.8会在 链表长度超过阈值的时候将链表转换为红黑树的原因！（链表时间复杂度为O(n)，红黑树为 O(logn).
因为红黑树的平均查找长度是log(n)，长度为8的时候，平均查找长度为3，如果继续使用链表，平均查找长度为8/2=4，这才有转换为树的必要
链表长度如果是小于等于6，6/2=3，虽然速度也很快的，但是转化为树结构和生成树的时间并不会太短
还有选择6和8，中间有个差值7可以有效防止链表和树频繁转换
假设一下，如果设计成链表个数超过8则链表转换成树结构，链表个数小于8则树结构转换成链表，如果一个HashMap不停的插入、删除元素，链表个数在8左右徘徊，就会频繁的发生树转链表、链表转树，效率会很低。
4.序列化 & 容量初始化
4.1 HashMap 实现了Serializable接口，因此它支持序列化，实现了Cloneable接口，能被克隆
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
4.2 在实际开发中使用HashMap的时候，最好设置一个初始容量，防止经常扩容操作耗费性能！
//默认的构造函数
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//指定容量大小
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//指定容量大小和负载因子大小
public HashMap(int initialCapacity, float loadFactor) {
//指定的容量大小不可以小于0,否则将抛出IllegalArgumentException异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//判定指定的容量大小是否大于HashMap的容量极限
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//指定的负载因子不可以小于0或为Null，若判定成立则抛出IllegalArgumentException异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
// 设置“HashMap阈值”，当HashMap中存储数据的数量达到threshold时，就需要将HashMap的容量加倍。
this.threshold = tableSizeFor(initialCapacity);
}
//传入一个Map集合,将Map集合中元素Map.Entry全部添加进HashMap实例中
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
//此构造方法主要实现了Map.putAll()
putMapEntries(m, false);
}5. 什么条件扩容
5.1 table 数组默认是16个长度，类型是Node<K,V>[] tab，即里面存放的是Node<K,V> 类型
hashmap 中 put中 Note<K,V>是单链表结构
Node<K,V>[] tab; Node<K,V> first, e;
5.2 resize 方法
a.第一次初始化table数组 DEFAULT_INITIAL_CAPACITY=16 ，DEFAULT_LOAD_FACTOR = 0.75f
b.当 size > threshold=16*0.74=12 时扩容 capacity =32
6. pos定位 & 扩容
数组容量2的倍数：1 提高运算速度；2 增加散列度，降低冲突；3 减少内存碎片
hash函数与pos定位：hashcode的高16位与低16位进行异或求模，增加了散列度，降低了冲突
插入冲突：通过单链表解决冲突，如果链表长度超过（TREEIFY_THRESHOLD=8），进行单链表和红黑树的转换以提高查询速度
扩容：扩容的条件：实际节点数大于等于容量的四分之三；扩容后数据排布：要么是原下标的位置；要么是原下标+原容量的位置
参考文档
https://jsbintask.cn/2019/02/27/jdk/jdk8-hashmap-sourcecode/
https://www.jianshu.com/p/003256ce41ce
https://www.jianshu.com/p/ee0de4c99f87
https://www.jianshu.com/p/86bc7f8f5c55
https://www.nowcoder.com/discuss/151172
扫一扫
793
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
