引言
hash表的应用场景：快速查找，通过计算桶下标查找元素。
链表过长，查找性能降低，优化方式：扩容或红黑树。
文章目录
一、Map继承体系
二、底层数据结构
.net中的dictionary就是选用质数作为数组容量，不用二次hash，直接用hashcode值，也能均匀分布，追求的是均匀分布。
而JAVA中的HashMap更注重实现的性能。数组容量为2的n次幂的问题时，如果都是偶数，即使有二次hash，也会造成分布不均匀。
三、put方法流程
扩容是在元素添加后进行的，添加元素，达到扩容条件，扩容，迁移数据。
源码如下：
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 为null 或者没有为 table 分配内存，就resize一次
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 指定hash值节点为空则直接插入，这个(n - 1) & hash才是表中真正的哈希
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 如果不为空
else {
Node<K,V> e; K k;
// 计算表中的这个真正的哈希值与要插入的key.hash相比
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 若不同的话，并且当前节点已经在 TreeNode 上了
else if (p instanceof TreeNode)
// 采用红黑树存储方式
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// key.hash 不同并且也不再 TreeNode 上，在链表上找到 p.next==null
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 在表尾插入
p.next = newNode(hash, key, value, null);
// 新增节点后如果节点个数到达阈值，则进入 treeifyBin() 进行再次判断
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果找到了同 hash、key 的节点，那么直接退出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 更新 p 指向下一节点
p = e;
}
}
// map中含有旧值，返回旧值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// map调整次数 + 1
++modCount;
// 键值对的数量达到阈值，需要扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
jdk1.7 put 过程：
不同的key计算出来的hsahcode值很大，无法直接用作下标，会将hashcode和数组长度进行与运算，得到下标值，这样不同的key下标值可能是一样的。
头插法，插入链表中。
put结果返回的值是原来key对应的值，是老的值，并不是新的值。
四、多线程下的问题
1、扩容死链（1.7）
后续访问时，a、b循环引用，造成死循环
2、 数据错乱（1.7、1.8）
五、key能否为null
对象equals一样，则hashcode一定相同，但hashcode一样的两个对象，不一定equals相等。
key要不可变，例子：
六、String对象的hashcode如何设计
使用31，分布性更好，同时方便计算：
七、扩容机制
jdk 1.8扩容机制
HashMap 中的扩容机制是由 resize() 方法来实现的,1.8实现：
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
// 存储old table 的大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 存储扩容阈值
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
// 如果old table数据已达最大，那么threshold也被设置成最大
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
}
// 如果oldThr !> 0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 如果old table <= 0 并且 存储的阈值 <= 0
else { // zero initial threshold signifies using defaults
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"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 如果第一次进行table 初始化不会走下面的代码
// 扩容之后需要重新把节点放在新扩容的数组中
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;
}
jdk 1.8中HashMap 扩容：
1、先确定新数组的容量和阈值
2、遍历老table，把老的table中数据放到新table中
（1）当前位置只有一个元素，计算元素在新数组中的位置，直接放进去
（2）当前节点已经树化，进行树拆分。拆分成高位链和低位链，两个链中，链的长度小于树退化阈值，树退化成链表；拆分后链表长度大于树退化阈值，仍然是树。
（3）当前桶位是链表，拆分成高位链和低位链放到新table中。
低位链（hash值&oldCap == 0）：新table中位置，与当前一致。
高位链（hash值&oldCap == 1）：新table中位置，原下标+老容量值。
jdk 1.7扩容机制
jdk 1.7中HashMap 扩容：
当前数组长度的2倍，转移元素，两层遍历，遍历数组和链表，获取下标，将元素的next指向新数组的头部，头部的next指转移的元素，头插法。
计算下标时，一般是扩容后的长度+原来的下标值。
rehash，只有扩容后的长度大于2的30次方，才会进行rehash，重新计算hash值。一般不会rehash。除非修改JVM中的参数。
1.7中扩容后的问题是，原来链表中的数据是1、2、3，扩容后的顺序变成了3、2、1.单线程的时候没有太大问题，但多线程时会有问题。
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
代码中可以看到，如果原有table长度已经达到了上限，就不再扩容了。
如果还未达到上限，则创建一个新的table，并调用transfer方法：
/**
* Transfers all entries from current table to newTable.
*/
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next; //注释1
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity); //注释2
e.next = newTable[i]; //注释3
newTable[i] = e; //注释4
e = next; //注释5
}
}
}
transfer方法的作用是把原table的Node放到新的table中，使用的是头插法，也就是说，新table中链表的顺序和旧列表中是相反的，在HashMap线程不安全的情况下，这种头插法可能会导致环状节点。
jdk1.8解决了这个问题，扩容后的顺序不会改变。
八、1.7与1.8不同汇总
1、底层数据结构不同
1.7 数组+ 链表，1.8 数组 + 链表 + 红黑树
2、put过程中的区别
1、链表插入节点时，1.7是头插法，1.8是尾插法
2、1.7是大于等于阈值且没有空位时才扩容，1.8是大于阈值就扩容
3、1.8在扩容计算Node索引时，会优化
3、扩容过程中的区别
1、1.7中扩容后会改变链表中数据原来的顺序。
998
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
