HashMap
HashMap 单向链表结构，底层维护的是数组，通过next 节点来维护下一个节点，
元素所在位置 是 通过 key 获得hashCode（(h = key.hashCode()) ^ (h >>> 16)），然后根据hashCode来 位与（&）数组的长度来计算该 key 落到数组的位置。
put时会数据会保存到该位置上，添加时会判断该位置存不存在元素，如果不存在，则添加到该位置的第一个元素上，并设置该元素的next为null，如果存在则判断是否一致，如果一致则覆盖数据返回旧值，如果不一致就添加到next为null的元素后面。
当添加完数据时，判断该数组的已用长度是否超过了扩容大小，该位置下的元素是否需要转换成红黑树存储
初始化时 默认数组长度为16，如果指定了长度不是2的倍数，会向上取 2 的倍数
扩容因子为075f,即当超过12时即进行扩容，扩容规则是扩容2倍，
newCap = oldCap << 1
当该位置下的元素超过 8 （ 转红黑树的因子（TREEIFY_THRESHOLD=8））大小时 且 数组的长度超过64 ，会将链表结构转换成红黑树
put 的过程
1.通过hash算法根据key获得一个hash 即 hash（key）
2.如果数组为空，则进行初始化数组
n = (tab = resize()).length;
//resize():
newCap = DEFAULT_INITIAL_CAPACITY;//1 << 4 // aka 16
// DEFAULT_LOAD_FACTOR = 0.75f; 扩容因子
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
3.判断key最终会落到数组的哪个节点下，如果该位置为空，则进行保存
//根据数组的长度-1 与（&） 上 hash算法的结果，
//最终能获得一个位于[0-15]或[0-数组.lenth-1]的值，即节点的下标位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
(hash %16 和hash & 15 得到的结果是相同的，为什么要采用 & 的操作)
因为& 的操作效率比较高
4.判断key最终会落到数组的哪个节点下，如果该位置不为空
1.如果key值相同则进行覆盖
2.如果key值不相同
1.采用红黑树的方式
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
2.采用链表的方式，会依次遍历该及节点链表中的节点是否为空，如果不为空则保存到节点的下个节点中
即 node.next = p (: p = tab[i = (n - 1) & hash]))
p.next = newNode(hash, key, value, null);
//如果该节点下的链表节点的长度大于等于8 //TREEIFY_THRESHOLD = 8;
//binCount 从0开始遍历的
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//转换成红黑树，类似二叉树
treeifyBin(tab, hash);
5.保存完节点之后，进行判断是否需要扩容
数组某节点下的链表的节点是数的大小超过8的时候，会进行转换成红黑树，
那么如果数组的节点呢? 当map的长度超过数组的长度*0.75的时候，会进行扩容，扩容成数组长度16 <<1 再次扩容的时候就是 16*0.75<< 1
++modCount;
//threshold = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
if (++size > threshold)
resize();
代码：
//HashMap 的内部数据结构:基于数组+链表（单向）
transient Node<K,V>[] table;
//数组的默认大小是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//扩容因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当数组下的链表节点超过这个数的时候，转换成红黑树
static final int TREEIFY_THRESHOLD = 8;
// 存储 数据
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
// hash值得计算： 获得key的hashcode 并与hashcode的高16位进行异或操作，
//HashMap对象的key、value值均可为null。
//hash 算法的作用就是为了Node节点落点的一个浅析计算
//hash 算法：key.hashCode ^ key.hashCode 的高16位
static final int hash(Object key) {
//获得key的hashCode值，
//获得哈市Code的高16位，
//进行^ 异或操作
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
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)
// 如果table 还未初始化，则进行初始化
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// 根据hashcode ^ hashcode>>>16 得到的 hash 值 与 table.length-1 进行与操作 ,会得到该key值应落到数组的对应的节点下
// 原理同 hashcode % table.length ,但是性能上 & 比 % 高
tab[i] = newNode(hash, key, value, null);
else {
// 如果根据key值计算落在数组的对应的节点已经存在数据了， 则进行判断该位置中的链表结构中的第一个值是否相同，
// hash 、key 相同的话则直接返回
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 {
// 如果 数组中对应的位置节点已经存在数据了，则循环查询next为null的，存储到此列表结构的后面
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 如果根据key计算落到数组的位置 中的链表结构已经存在大于8个元素了，则将node 节点转换成红黑树存储
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;
}
}
// 如果该key值，已经存在了，则进行替换，并返回旧的值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 如果hashmap的数组中有数据的位置大于扩容因子容量了，则进行扩容操作。
if (++size > threshold)
resize();
// HashMap 没有实现
// 对LinkedHashMap 有用，用来回调移除最早放入Map的对象
afterNodeInsertion(evict);
return null;
}
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
// 如果是第一次进来，则默认初始化大小是16
newCap = DEFAULT_INITIAL_CAPACITY;
// 扩容量也进行赋值：16 * 0.75f
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;
// 创建 hashMap 数组容器
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 容器大小发生变化，则将 旧的容器中的节点数据 根据新的规则重新将数据存储到新的容器中
if (oldTab != null) {
// do something ...
}
return newTab;
}
// hashMap 的node节点 内部类
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
线程不安全的问题
-
java.util.HashMap.TreeNode#balanceInsertion 方法里会死循环
-
转换异常
Exception in thread "thread_hash_map81" java.lang.ClassCastException: java.util.HashMap$Node cannot be cast to java.util.HashMap$TreeNode
at java.util.HashMap$TreeNode.moveRootToFront(HashMap.java:1827)
at java.util.HashMap$TreeNode.putTreeVal(HashMap.java:2007)
at java.util.HashMap.putVal(HashMap.java:637)
at java.util.HashMap.put(HashMap.java:611)
at com.guaoran.interview.in2020.program.HashMapThreadUnSafeDemo.run(HashMapThreadUnSafeDemo.java:31)
at java.lang.Thread.run(Thread.java:745)
因为目前发现的线程不安全问题跟红黑树有关系，目前还不了解红黑树，待研究。
4106
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
