HashMap
【HashMap专题】
[1] HashMap是什么？
HashMap是map接口下常用的集合，它具有查询快，插入删除方便的优点。
[2] HashMap的底层是怎样的？
HashMap的底层是在JDK1.7的时候，是数组+链表；在JDK1.8的时候，底层是数组+链表+红黑树。
[3] HashMap的树化及其链表化机制及其原因？
一、链表树化的条件是：哈希桶数组的长度大于等于64且链表中节点的个数大于等于8，不满足哈希桶数组的长度大于等于64时执行扩容操作
1.链表长度大于8，官方源码如下：
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
2.当满足条件1以后调用treeifyBin方法转化红黑树。该方法中，数组如果长度小于MIN_TREEIFY_CAPACITY（64）就选择扩容，而不是转化为红黑树。
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
原因：
通过复杂度分析，我们都知道，链表取元素是从头结点一直遍历到对应的结点，这个过程的复杂度是O(N) ，而红黑树基于二叉树的结构，查找元素的复杂度为O(logN) ，通过他们的曲线也可以看出来，数据越多红黑树查询次数越低，性能也就越高。所以，当元素个数过多时，用红黑树存储可以提高搜索的效率。
也可以通过泊松分布，我们应该在保证查询性能的情况下尽可能不要树化。冲突后的拉链长度和概率结果如下，可以看到第8个节点几率是滴7个节点的1/14。
0: 0.60653066
1: 0.30326533
2: 0.07581633
3: 0.01263606
4: 0.00157952
5: 0.00015795
6: 0.00001316
7: 0.00000094
8: 0.00000006既然红黑树的效率高，那怎么不一开始就用红黑树存储呢？
这其实是基于空间和时间平衡的考虑，JDK的源码里已经对这个问题做了解释：
* Because TreeNodes are about twice the size of regular nodes, we * use them only when bins contain enough nodes to warrant use * (see TREEIFY_THRESHOLD). And when they become too small (due to * removal or resizing) they are converted back to plain bins.看注释里的前面四行就不难理解，单个 TreeNode 需要占用的空间大约是普通 Node 的两倍，所以只有当包含足够多的 Nodes 时才会转成 TreeNodes，这个足够多的标准就是由 TREEIFY_THRESHOLD 的值（默认值8）决定的。而当桶中节点数由于移除或者 resize (扩容) 变少后，红黑树会转变为普通的链表，这个阈值是 UNTREEIFY_THRESHOLD（默认值6）
树链表化的条件是：树中节点数小于等于6。
**原因：**主要是一个过渡，避免链表和红黑树之间频繁的转换。如果阈值是7的话，删除一个元素红黑树就必须退化为链表，增加一个元素就必须树化，来回不断的转换结构无疑会降低性能，所以阈值才不设置的那么临界。
[4] HashMap的扩容机制是怎样的？
HashMap初始容量是16。
HashMap会使用size记录当前数组的占用个数，当size大于扩容阈值threshold时，将会使用resize（）方法进行扩容操作，扩容增量是原容量的1倍（在put方法结束后就有这个函数）。
if (++size > threshold)//特别注意，此处的size是指键值对的个数，而不是当前哈希表的长度
resize(); //特别注意，此处的threshold=capacity*loadFactor，阀值=桶长*负载因子
**举个例子：**初始情况下，HashMap的初始容量（capacity）16，加载因子（loadFactor）为0.75，那么当前的扩容阀值（threshold）为16*0.75=12。当前键值对的个数（size）大于扩容阀值（threshold），扩容成原容量的2倍，即从16扩容到32、64、128 … 但是他不会无限制扩容下去，扩充阈值参数为Integer.MAX_VAULE=1 << 30; 。
[5] 为什么HashMap初始容量是16？
首先，length为2的整数次幂的话，h&(length-1)相当于对length取模，既保证了散列均匀，又提升了效率。
[6] 为什么HashMap加载因子（loadFactor）为0.75？
HashMap加载因子时真实数据和数组长度的比值。如果加载因子太小，就会造成过多的hash冲突，致使效率降低。太小，就会频繁扩容，浪费空间，降低效率。所以它不能太大也不能太小，为什么取（loadFactor）为0.75？与离散数学中的泊松分布有关。
加载因子过高，例如为1，虽然减少了空间开销，提高了空间利用率，hash冲突太多。但同时也增加了查询时间成本；
加载因子过低，例如0.5，虽然可以减少查询时间成本，但是空间利用率很低，同时提高了rehash操作的次数。在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少rehash操作次数，所以，一般在使用HashMap时建议根据预估值设置初始容量，减少扩容操作。
什么是泊松分布？
泊松分布是统计学和概率学常见的离散概率分布，适用于描述单位时间内随机事件发生的次数的概率分布。
等号的左边，P 表示概率，N表示某种函数关系，t 表示时间，n 表示数量。等号的右边，λ 表示事件的频率。
在理想情况下，使用随机哈希码，在扩容阈值（加载因子）为0.75的情况下，节点出现在频率在Hash桶（表）中遵循参数平均为0.5的泊松分布。忽略方差，即X = λt，P(λt = k)，其中λt = 0.5的情况，按公式：
计算结果如上述的列表所示，当一个bin中的链表长度达到8个元素的时候，概率为0.00000006，几乎是一个不可能事件。所以我们可以知道，其实常数0.5是作为参数代入泊松分布来计算的，而加载因子0.75是作为一个条件，当HashMap长度为length/size ≥ 0.75时就扩容，在这个条件下，冲突后的拉链长度和概率结果为：
0: 0.60653066
1: 0.30326533
2: 0.07581633
3: 0.01263606
4: 0.00157952
5: 0.00015795
6: 0.00001316
7: 0.00000094
8: 0.00000006
从上面的表中可以看到当桶中元素到达8个的时候，概率已经变得非常小，也就是说用0.75作为加载因子，每个碰撞位置的链表长度超过８个是几乎不可能的。
那么为什么不可以是0.8或者0.6呢？
HashMap中除了哈希算法之外，有两个参数影响了性能：初始容量和加载因子。初始容量是哈希表在创建时的容量，加载因子是哈希表在其容量自动扩容之前可以达到多满的一种度量。
**在维基百科来描述加载因子：**对于开放定址法，加载因子是特别重要因素，应严格限制在0.7-0.8以下。超过0.8，查表时的CPU缓存不命中（cache missing）按照指数曲线上升。因此，一些采用开放定址法的hash库，如Java的系统库限制了加载因子为0.75，超过此值将resize散列表。
在设置初始容量时应该考虑到映射中所需的条目数及其加载因子，以便最大限度地减少扩容rehash操作次数，所以，一般在使用HashMap时建议根据预估值设置初始容量，以便减少扩容操作。
选择0.75作为默认的加载因子，完全是时间和空间成本上寻求的一种折衷选择。
[7] 为什么桶数组的长度是2^n
因为在计算元素该存放的位置的时候，用到的算法是将元素的hashcode与当前map长度-1进行与运算**(i=（n-1）&hash)**。如果map长度为2的幂次，那n-1的二进制一定为11111…的形式。这可以保证每一位参与有有意义的与运算，即可以把结果i控制在0~n-1之间。能够充分利用数组，有效减少哈希冲突。
[8] HashMap线程安全吗？为什么？
link，link
https://blog.csdn.net/swpu_ocean/article/details/88917958
https://blog.csdn.net/swpu_ocean/article/details/88917958
HashMap的线程不安全主要体现在下面两个方面：
- 在JDK1.7中，当并发执行扩容操作时会造成死链和数据丢失的情况。
在扩容时产生死链：HashMap的线程不安全主要是发生在扩容函数中，即根源是在transfer函数。HashMap的扩容操作，重新定位每个桶的下标，并采用头插法将元素迁移到新数组中。头插法会将链表的顺序翻转，这也是形成死循环的关键点。假设两个线程同时进行resize, A->B 第一线程在处理过程中比较慢，第二个线程已经完成了倒序完成了B-A 那么就出现了循环，B->A->B.
在扩容时数据丢失：当多个线程同时进来，检测到总数量超过门限值的时候就会同时调用 resize 操作，各自生成新的数组并 rehash 后赋给该 map 底层的数组，结果最终只有最后一个线程生成的新数组被赋给该 map 底层，其他线程的均会丢失。
- 在JDK1.8中，在并发执行put操作时会发生数据覆盖的情况。
数据覆盖导致的数据丢失：在JDK1.7中，hashmap的链表采用了尾插法。如果有两个线程A和B，都进行插入数据，刚好这两条不同的数据经过哈希计算后得到的哈希码是一样的，且该位置还没有其他的数据。假设一种情况，线程A通过if判断，该位置没有哈希冲突，进入了if语句，还没有进行数据插入，这时候CPU就把资源让给了线程B，线程A停在了if语句里面，线程B判断该位置没有哈希冲突（线程A的数据还没插入），也进入了if语句，线程B执行完后，轮到线程A执行，现在线程A直接在该位置插入而不用再判断。这时候，你会发现线程A把线程B插入的数据给覆盖了。发生了线程不安全情况。本来在HashMap中，发生哈希冲突是可以用链表法或者红黑树来解决的，但是在多线程中，可能就直接给覆盖了。
[9] 关于HashMap的key值的数据类型不能为基础类型的原因？
HashMap是利用HashCode()来区别两个不同的对象。而HashCode()是本地方法，是用C或C++来实现的，即该方法是直接返回对象的内存地址。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
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
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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];
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;
}
[10] 其他总结
HashMap 有什么特点？
JDK8 之前底层实现是数组 + 链表，JDK8 改为数组 + 链表/红黑树，节点类型从Entry 变更为 Node。主要成员变量包括存储数据的 table 数组、元素数量 size、加载因子 loadFactor。
table 数组记录 HashMap 的数据，每个下标对应一条链表，所有哈希冲突的数据都会被存放到同一条链表，Node/Entry 节点包含四个成员变量：key、value、next 指针和 hash 值。
HashMap 中数据以键值对的形式存在，键对应的 hash 值用来计算数组下标，如果两个元素 key 的 hash 值一样，就会发生哈希冲突，被放到同一个链表上，为使查询效率尽可能高，键的 hash 值要尽可能分散。
HashMap 默认初始化容量为 16，扩容容量必须是 2 的幂次方、最大容量为 1<< 30 、默认加载因子为 0.75。
HashMap 相关方法的源码
JDK8 之前
hash：计算元素 key 的散列值
① 处理 String 类型时，调用 stringHash32 方法获取 hash 值。
② 处理其他类型数据时，提供一个相对于 HashMap 实例唯一不变的随机值 hashSeed 作为计算初始量。
③ 执行异或和无符号右移使 hash 值更加离散，减小哈希冲突概率。
indexFor：计算元素下标
将 hash 值和数组长度-1 进行与操作，保证结果不会超过 table 数组范围。
get：获取元素的 value 值
① 如果 key 为 null，调用 getForNullKey 方法，如果 size 为 0 表示链表为空，返回 null。如果 size 不为 0 说明存在链表，遍历 table[0] 链表，如果找到了 key 为 null 的节点则返回其 value，否则返回 null。
② 如果 key 为 不为 null，调用 getEntry 方法，如果 size 为 0 表示链表为空，返回 null 值。如果 size 不为 0，首先计算 key 的 hash 值，然后遍历该链表的所有节点，如果节点的 key 和 hash 值都和要查找的元素相同则返回其 Entry 节点。
③ 如果找到了对应的 Entry 节点，调用 getValue 方法获取其 value 并返回，否则返回 null。
put：添加元素
① 如果 key 为 null，直接存入 table[0]。
② 如果 key 不为 null，计算 key 的 hash 值。
③ 调用 indexFor 计算元素存放的下标 i。
④ 遍历 table[i] 对应的链表，如果 key 已存在，就更新 value 然后返回旧 value。
⑤ 如果 key 不存在，将 modCount 值加 1，使用 addEntry 方法增加一个节点并返回 null。
resize：扩容数组
① 如果当前容量达到了最大容量，将阈值设置为 Integer 最大值，之后扩容不再触发。
② 否则计算新的容量，将阈值设为 newCapacity x loadFactor 和 最大容量 + 1 的较小值。
③ 创建一个容量为 newCapacity 的 Entry 数组，调用 transfer 方法将旧数组的元素转移到新数组。
transfer：转移元素
① 遍历旧数组的所有元素，调用 rehash 方法判断是否需要哈希重构，如果需要就重新计算元素 key 的 hash 值。
② 调用 indexFor 方法计算元素存放的下标 i，利用头插法将旧数组的元素转移到新数组。
JDK8
hash：计算元素 key 的散列值
如果 key 为 null 返回 0，否则就将 key 的 hashCode 方法返回值高低16位异或，让尽可能多的位参与运算，让结果的 0 和 1 分布更加均匀，降低哈希冲突概率。
put：添加元素
① 调用 putVal 方法添加元素。
② 如果 table 为空或长度为 0 就进行扩容，否则计算元素下标位置，不存在就调用 newNode 创建一个节点（node节点内存储的属性有hash，key，value，next）。
③ 如果存在且是链表，如果首节点和待插入元素的 hash 和 key 都一样，更新节点的 value。
④ 如果首节点是 TreeNode 类型，调用 putTreeVal 方法增加一个树节点，每一次都比较插入节点和当前节点的大小，待插入节点小就往左子树查找，否则往右子树查找，找到空位后执行两个方法：balanceInsert 方法，插入节点并调整平衡、moveRootToFront 方法，由于调整平衡后根节点可能变化，需要重置根节点。
⑤ 如果都不满足，遍历链表，根据 hash 和 key 判断是否重复，决定更新 value 还是新增节点。如果遍历到了链表末尾则添加节点，如果达到建树阈值 7，还需要调用 treeifyBin 把链表重构为红黑树。
⑥ 存放元素后将 modCount 加 1，如果 ++size > threshold ，调用 resize 扩容。
get ：获取元素的 value 值
① 调用 getNode 方法获取 Node 节点，如果不是 null 就返回其 value 值，否则返回 null。
② getNode 方法中如果数组不为空且存在元素，先比较第一个节点和要查找元素的 hash 和 key ，如果都相同则直接返回。
③ 如果第二个节点是 TreeNode 类型则调用 getTreeNode 方法进行查找，否则遍历链表根据 hash 和 key 查找，如果没有找到就返回 null。
resize：扩容数组
重新规划长度和阈值，如果长度发生了变化，部分数据节点也要重新排列。
重新规划长度
① 如果当前容量 oldCap > 0 且达到最大容量，将阈值设为 Integer 最大值，return 终止扩容。
② 如果未达到最大容量，当 oldCap << 1 不超过最大容量就扩大为 2 倍。
③ 如果都不满足且当前扩容阈值 oldThr > 0，使用当前扩容阈值作为新容量。
④ 否则将新容量置为默认初始容量 16，新扩容阈值置为 12。
重新排列数据节点
① 如果节点为 null 不进行处理。
② 如果节点不为 null 且没有next节点，那么通过节点的 hash 值和 新容量-1 进行与运算计算下标存入新的 table 数组。
③ 如果节点为 TreeNode 类型，调用 split 方法处理，如果节点数 hc 达到6 会调用 untreeify 方法转回链表。
④ 如果是链表节点，需要将链表拆分为 hash 值超出旧容量的链表和未超出容量的链表。对于hash & oldCap == 0 的部分不需要做处理，否则需要放到新的下标位置上，新下标 = 旧下标 + 旧容量。
Q3：HashMap 为什么线程不安全？
JDK7 存在死循环和数据丢失问题。
数据丢失：
- 并发赋值被覆盖： 在
createEntry方法中，新添加的元素直接放在头部，使元素之后可以被更快访问，但如果两个线程同时执行到此处，会导致其中一个线程的赋值被覆盖。 - 已遍历区间新增元素丢失： 当某个线程在
transfer方法迁移时，其他线程新增的元素可能落在已遍历过的哈希槽上。遍历完成后，table 数组引用指向了 newTable，新增元素丢失。 - 新表被覆盖： 如果
resize完成，执行了table = newTable，则后续元素就可以在新表上进行插入。但如果多线程同时resize，每个线程都会 new 一个数组，这是线程内的局部对象，线程之间不可见。迁移完成后resize的线程会赋值给 table 线程共享变量，可能会覆盖其他线程的操作，在新表中插入的对象都会被丢弃。
死循环： 扩容时 resize 调用 transfer 使用头插法迁移元素，虽然 newTable 是局部变量，但原先 table 中的 Entry 链表是共享的，问题根源是 Entry 的 next 指针并发修改，某线程还没有将 table 设为 newTable 时用完了 CPU 时间片，导致数据丢失或死循环。
JDK8 在 resize 方法中完成扩容，并改用尾插法，不会产生死循环，但并发下仍可能丢失数据。可用 ConcurrentHashMap 或 Collections.synchronizedMap 包装成同步集合。
1282
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
