HashMap 学习心得总结

HashMap 底层实现原理：
1.7 数组+链表
1.8 数组+链表+红黑树
红黑树的引入是为了增大它的查询效率
正常的遍历链表时间复杂度为O(n),红黑树查询的效率是O(logn)
扩容机制：
Hash Map中有两个变量，数组的
默认长度

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

默认长度为16，默认的负载因子为0.75，当数组的长度超过默认长度负载因子的大小时，就会触发扩容，扩容的大小是原先长度的两倍。
其实这个在1.7和1.8中也是不一样的，在1.8中，只要容量超过默认长度负载因子就会扩容，但是在1.7中如果容量超过这个值时，再插入的元素进行hash取模后，发现有空位，会优先补充空位，而不是触发扩容。
1.7：新增元素前

新增元素后 会优先补充空位

1.8 新增元素前

新增元素后 会进行扩容

树化机制：

static final int TREEIFY_THRESHOLD = 8; static final int
MIN_TREEIFY_CAPACITY = 64;

当链表长度 >= 8 时，且数组长度 >= 64 时，就会进行树化
退化机制：
1、扩容时拆分树节点：

static final int UNTREEIFY_THRESHOLD = 6; //当链表长度 <= 6 时

2、移除树中结点元素时： 当树的根节点，树的左子节点，树的右子节点，树的左孙节点有一个为null时，就会退化为链表

为什么要用2的幂次作为数组容量长度

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的幂次，那么这个结果就不能和取模运算的结果一致
• 扩容时要移动链表元素，可以判断这一串的二次hash值和原始长度进行一个按位与的值，如果是0就不需要移动，如果不是0就将需要移动的元素，移动到原来位置+原始容量的位置

总结：2的n次幂会有一个更好的性能，但是可能会导致hash分布性能不太好。如果选择一个较大的质数做数组容量，都不需要使用二次hash，就可以得到一个比较好的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;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
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) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}`final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict){
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
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) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}

• 首次使用会创建数组
• 计算索引值
• 如果桶下标没占用会创建一个node占位返回
• 如果已经被占用：
• 如果是TreeNode，就进行红黑树的添加或更新逻辑
• 如果是普通节点，就进行链表的添加和更新逻辑，如果两边超过树化阈值，走树化逻辑。
• 返回前判断容量是否超过扩容阈值，如果超过，就进行扩容

链表的插入有所不同
1.7中使用的是头插法，1.8中使用的是尾插法，1.7的头插法在多线程情况下有可能会出现循环链表的情况
负载因子为什么是0.75
这个数值均衡了空间和时间，既能做到不浪费空间，又能提升效率
HashMap的安全性
整体方法都没有使用同步，所以是不安全的
1.7 的时候可能会触发扩容死链
头插法在多线程情况下有可能会出现循环链表的情况

1.7 & 1.8 可能会触发数据错乱，两个hash值相同的元素，用两个线程分别存放到hashmap同一个位置，可能存在一个值覆盖另一个值的情况

这就是一些我学习了hashmap后的一些学习笔记 and 心得体会 ，希望能够对大家有所帮助！