标签：头结点 public 使用场景 基本 高效 还需 value while size
目录
数据结构与算法目录(https://www.cnblogs.com/binarylei/p/10115867.html)
在Java 数据结构 - 散列表原理一文中，提到评价一个散列表的标准有三个：散列函数、散列冲突、加载因子（动态扩容）三个指标。那像 HashMap 这样工业级的散列表应该具有哪些特性？
散列函数追求的是简单高效、分布均匀。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}说明： HashMap 使用最简单的余数法作为散列函数，使用位运算来提高执行效率。
i = (n - 1) & hash(kye)。其中，hashCode() 返回的是 Java 对象的 hash code。比如 String 类型的对象的 hashCode() 就是下面这样：
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}散列冲突解决方案有开放地址探测法和拉链法，两种方案的基本使用场景如下：
像 ThreadLocalMap 数据量小，可以直接使用线性探测法。 HashMap 的数据量可能非常大，只能使用拉链法解决散列冲突。即使负载因子和散列函数设计得再合理，也免不了会出现拉链过长的情况，一旦出现拉链过长，则会严重影响 HashMap 的性能。
于是，在 JDK1.8 中，HashMap 引入了红黑树。
当链表长度太长（默认超过 8）时，链表就转换为红黑树。我们可以利用红黑树快速增删改查的特点，提高 HashMap 的性能。
当红黑树结点个数少于 8 个的时候，又会将红黑树转化为链表。因为在数据量较小的情况下，红黑树要维护平衡，比起链表来，性能上的优势并不明显。但 HashMap 也不是直接使用链表，当链表的长度大于 8 时会转换会红黑树。
装载因子（loadFactor）的计算公式如下：
散列表的装载因子 = 表中的元素个数 / 散列表的长度装载因子实际的含义是如何动态扩容的问题。其阈值的设置要权衡时间、空间复杂度。如果内存空间不紧张，对执行效率要求很高，可以降低负载因子的阈值；相反，如果内存空间紧张，对执行效率要求又不高，可以增加负载因子的值，甚至可以大于 1。
如果元素个数超过装载因子阈值就会触发散列表的扩容，当然我们也可以只扩容不搬运数据，当插入时从老容器中搬移部分数据。不过这会浪费内存，这相当于将一只扩容的时间复杂度摊还到多次插入过程中。HashMap 在扩容进会一次性的将数据从老容器中搬移到新容器中。
HashMap 中装载因子动态扩容问题：
装载因子和动态扩容。最大装载因子默认是 loadFactor = 0.75，当 HashMap 中元素个数超过 0.75 * capacity（capacity 表示散列表的容量）的时候，就会启动扩容，每次扩容都会扩容为原来的两倍大小。
初始大小。HashMap 默认的初始大小是 16。如果事先知道大概的数据量有多大，可以通过修改默认初始大小，减少动态扩容的次数，这样会大大提高 HashMap 的性能。
（1）扩容相关属性
static final float DEFAULT_LOAD_FACTOR = 0.75f;
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
static final int MAXIMUM_CAPACITY = 1 << 30;
transient Node<K,V>[] table; // 表示hash数组，数组长度必须为 2^n
transient int size; // 表示当前表中元素的个数
// 当threshold>size时扩容。threshold = table.length * loadFactor
int threshold;
final float loadFactor; （2）红黑树相关属性
static final int TREEIFY_THRESHOLD = 8; // 链表转红黑树的阀值
static final int UNTREEIFY_THRESHOLD = 6; // 红黑树转链表的阀值
// 如果HashMap的容量小于64先启动扩容，只有容量大于64才会转红黑树
static final int MIN_TREEIFY_CAPACITY = 64;
HashMap 中插入 key 时，有以下几种可能：
/**
* @param onlyIfAbsent 只有元素不存在时才插入
* @param evict 数组是否在扩容状态，LinkedHashMap中有使用
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 1. 初始化数组
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 2. 有空闲位置，直接存储即可
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 3. 没有空闲位置，二种情况：可能是hash碰撞，也可能是该key对应的元素已经存在
else {
Node<K,V> e; K k;
// 3.1 元素已经存在，e变量保存旧值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 3.2 红黑树，先不管
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 3.3 遍历链表，如果key已经存在则保存到e中，如果不存在则直接追加到链表尾
else {
for (int binCount = 0; ; ++binCount) {
// 3.3.1 key不存在，直接追加不链表尾
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 判断链表是否要转红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 3.3.2 key存在，保存到到e中
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 3.4 key已经存在，判断是否替换旧值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 4. 判断是否需要扩容
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}说明： HashMap 允许 key 值为 null，因为判断一个 key 是否已经存在的条件是：p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))。
链表中 hash(key) 对应的数组没有元素时处理很简单，我们重点分析一下如果存在链表结构怎么处理。递归遍历链表，如果找到相同 key 的结点就退出循环，直接替换这个 key。如果遍历完链表都没有找到，则直接追加到链表尾，并判断是否需要转红黑树（长度大于 8）。
我们思考一下，HashMap 为什么要将链表的第一个元素单独进行判断，即第一个 if 语句。我想这是因为 HashMap 的加载因子 loadFactor = 0.75，也就是说数组容器的长度是大于 HashMap 中元素的个数。在绝大多数情况下，即如果不发生 hash 碰撞的理想情况，链表中都只有一个元素，这样可以快速返回。
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// hash(key) 对应的数组中存在数据，需要进一步查找对应的 key
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 1. 判断链表的第一个结点是不是指定的 key
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 2. 链表或红黑树递归查找 key
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;
}说明： 同样 HashMap 查找元素时，也先单独判断链表的第一个元素。
删除的代码也很简单，只是需要注意，要删除的元素是不是链表的头结点，因为数组的引用是指向这个头结点的。如删除结点 a1 时，需要将数组的引用指向新的头结点。
HashMap 扩容首先要确定扩容后的数组长度，再进行数据搬移。
HashMap 默认按原数组的 2 倍扩容。如果数组未初始化，则需要先进行初始化。初始化分如果没有指定数组初始化容量，按默认容量 16 进行初始化。如果指定了初始化容器 threshold（一定是 2n)，则按照 threshold 初始化，并根据加载因子重新计算扩容阀值 threshold = newCap * loadFactor。
下面，我们在看一下数据搬移，数据的搬移非常巧妙。由于数组的容量是 oldCap = 2n，扩容后数组的长度为原来的 2 倍 newThr = oldThr << 1。在 hash(key) 值不变的情况下，原先 arr[k] 重新 rehash 后只能在新数组的 arr[k] 或 arr[k + oldCap] 两个位置。如下图所示，原先数组长度为 8，a1 ~ a8 的 key 全部落到 arr[1] 上，重新 rehash 后部分 key 落到 arr[1] 部分落到 arr[9] 上：
final Node<K,V>[] resize() {
// 1. 确定数组扩容后的长度，默认的按2倍扩容
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 1.1 如果数组已经初始化，按原数组的2倍大小扩容
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
// 1.2 原数组未初始化，但设置初始化长度，按初始化长度进行初始化
} else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 1.3 原数组未初始化，按默认大小初始化数组
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 1.4 初始化扩容的阀值threshold=newCap * loadFactor
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
// 2. 数据搬移
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;
}每天用心记录一点点。内容也许不重要，但习惯很重要！
Java 数据结构 - HashMap 源码解读：如何设计工业级的散列表
标签：头结点 public 使用场景 基本 高效 还需 value while size
原文地址：https://www.cnblogs.com/binarylei/p/12455142.html
