HashMap的数据结构
数据结构
- String[]数组
首先想到的就是String[]数组,声明指定的长度后,然后根据索引向里面插入数据。但它的缺点是,长度不够时扩容麻烦。
-
ArrayList数组
面对这个缺点可以选择ArrayList数组,支持动态扩容,查询速度很快(可以根据索引快速查找),顺序插入也快。但它的缺点是,在数组的中间元素插入删除元素时,要移动索引,数据量大时,频繁插入删除速度就会慢。 -
LinkedList链表
-面对这个缺点可以选择LinkedList链表,插入删除元素快。但查询速度较慢。
ArrayList、LinkedList可以根据场景选择。
如果不知道场景是读多写少,还写多读少,能不能把二者优势结合?
- HashMap
JDK1.7:数组+链表
JDK1.8:数组+链表+红黑树
HashMap,集中数据、链表的优点。通过hash算法为key生成一个对应的int类型值作为数组下标,方便查询时快读定位元素,但有可能出现不同的key生成的int值一样,即hash冲突,这种情况就需要链表。把冲突的value值通过链表next关联起来。但如果数据量较大hash冲突较多,链表会很长,查找的时间复杂度为O(n)。
O(n),就代表数据量增大几倍,耗时也增大几倍。比如常见的遍历算法。再比如时间复杂度O(n^2 ),就代表数据量增大n倍时,耗时增大n的平方倍,这是比线性更高的时间复杂度。比如冒泡排序,就是典型的O(n^2)的算法,对n个数排序,需要扫描n×n次。
为什么在JDK1.8加入了红黑树
于是在JDK1.8加入了红黑树,来加快读取速度,提高查询性能。
比二叉树、b+Tree平衡二叉树性能好,变形开销小和读取路径短。查找时间复杂度为O(logn)。
O(logn),当数据增大n倍时,耗时增大logn倍(这里的log是以2为底的,比如,当数据增大256倍时,耗时只增大8倍,是比线性还要低的时间复杂度)。二分查找就是O(logn)的算法,每找一次排除一半的可能,256个数据中查找只要找8次就可以找到目标。
HashMap的数组容量为什么是2的整数次幂
/**
* 10000、16
* 必须是2的N次方,或者叫2的整数次幂
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
1、方便hash计算和数组的下标计算;
2、扩容有关:扩容后元素的位置可能是原来的位置,或者原来的位置+扩容大小,每次扩容后只会分散最多两个位置;
HashMap里的桶是什么
每个元素存的位置就叫桶,发生hash冲突后,链表或红黑树也是桶。
HashMap源码解析
关键的结构
/**
* 数组初始长度
* 10000、16
* 必须是2的N次方,或者叫2的整数次幂
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
/**
* 数组的最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 加载因子,扩容时使用,比如16*0.75f=12时就扩容
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 树化的阈值,链表树化的一个条件
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 反树化的阈值,树到链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 最小树化的数组容量,链表树化的另一个条件
* 16、32、64
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 数组
*/
transient Node<K,V>[] table;
/**
* 链表
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next; // 下个元素
// ...
}
/**
* JDK1.8加入的红黑树
*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
// ...
}
数组下标定位 (n-1)&hash
(n-1)&hash 等价于 hash%16,前者二进制运算性能更好。
16-1=15,二进制是1111,而&的特点是只有1:1时才为1,所以&运算后最大值为1111,最小值为0000,即0~15。与hash%16结果一样。
&运算规则可以参考:
Java中与&、或|、异或^运算符的使用规则与区别
put()流程
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
hash(Object key)等价于
static final int hash(Object key) {
if(key == null) return 0;
int h = key.hashCode(); //32位
int temp = h >>> 16; //向右位移16位,高位变低位,高位填充0
int hashValue = h ^ temp; //异或运算,结果更公平,使元素更加分散
return hashValue;
}
^运算的特点是0:0、1:1为0,1:0、0:1为1,结果为0或1的概率都为50,更加公平;向右位移16位,高位变低位,高位填充0,也即h低位和高位异或,使元素更加分散。结合上面&,最后这有低位1111参与&运算。
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); //next为null
// hash冲突时
else {
Node<K,V> e; K k;
// 桶里面的hash和新hash相同
// 1.key是同一个,p赋值给e,是否用value覆盖看下面
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);
// hash冲突,但key不相等
else {
for (int binCount = 0; ; ++binCount) {
// 放在链表的最后
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 树化,-1减掉自己
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果是自己break
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 转换,向下循环
p = e;
}
}
// key-value已存在,操作重复的值
if (e != null) {
V oldValue = e.value;
//onlyIfAbsent表示value只能赋值一次,默认为false,
//所以!onlyIfAbsent为true,表示可以用新value值替换旧value值
//或者onlyIfAbsent=true,但oldValue为null也可以替换
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
// 返回旧value值
return oldValue;
}
}
// 操作新值,记录修改次数,用于扩容
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
hash冲突
key=king和key=peter时,hash值不一样,但下标(n-1)&hash的值是一样的。
HashMap在JDK1.7中死循环的分析
JDK1.7中在多线程高并发情况下,使用HashMap的put()会引发死循环,造成CPU飙升接近100%,问题就出现在Entry链表形成环形结构,一旦形成环形结构,Entry的next的节点永远不会为空,就会产生死循环获取Entry。
原因就在于JDK1.7中作者为了提高链表查询效率,认为最后插入的可能会最近使用,就采取了头插法。在多线程高并发下就很容易形成环形链表。