HashMap原理
HashCode计算方式
s.hashcode=s[0]*31^{n-1} + s[1]*31^{n-2}+s[2]*31^{n-3} ... s[n-1]*31^{n-n}
选用31这个质数的原因:
- 经证明,31、33、37、41这几个质数套入上述公式计算获得的hashCode碰撞都很小;
- 31*i ==(i<<5) -i 现代的JVM都可以对此进行识别并优化,把乘法运算转为移位和减法运算,提高运算效率;
映射
创建一个固定长度的数组,然后用hashCode%数组来计算下标,因为求余数运算不可能超过除数即数组长度;
我们将每个数组下标对应的位置称为有个桶(bucket);
解决冲突-链表登场
像下图这样,如果有两个或多个元素的hashcode取余数组长度结果一样的话,就说发生了hash碰撞;它们之间构成一个链表,下一次在访问的时候先计算hashcode模长度找到下标,在顺着链表使用equals逐一比较直到找到元素;
rehash(重新计算桶下标)
当要加入的元素越来越多时,冲突也就会越来越多,链表越长,比较次数变多,查找效率变低;为了缩短链表,我们可以让数组变大,提升效率;
让数组长度翻一倍,即变为16,再次遍历每个元素重新计算下标
注意以下特征:
-
1.7中如果发生冲突,将元素放到链表头部;
-
1.8中如果发生冲突,将元素放到链表尾部;
-
初始大小为16,当元素超过了初始大小的3/4的时候,就会发生扩容,大小翻一番;
-
1.7需要移动的元素,扩容后顺序会颠倒;
-
1.8扩容后顺序保持;
1.8后对链表长度控制有新变化:
- 当链表长度过长时,会首先执行扩容;当扩容后大小超过64的时候,就不会进行扩容来减少链表长度了,当链表长度大于8的时候,将链表变成一个搜索二叉树(红黑树);
安全问题:1.8之前的ddos攻击 精心生成一大批hashcode相同的字符串
hashmap特性
上述过程就是hashmap的底层实现数据结构;
- HashMap(int i) 用来指定数组的初始大小;
- HashMap的key 必须实现hashCode 和 equals 方法,他要参与之前提到的各项运算;
- HashMap的value:可以是任意对象;
- 当用一个hash值的节点数不小于8时,将链表转换为红黑树,当节点不大于6时,将红黑树恢复为链表;
总结:面试的常见问题
-
HashMap底层的数据结构;
数组+链表+红黑树 -
负载因子的作用
决定了什么时候应该进行扩容,当元数个数/总长度>=负载因子时进行扩容;
如果太大造成链表长度过长,降低了效率;
如果太小,浪费空间; -
扩容的过程
容量翻倍;遍历原来的链表,重新计算hashcode和将桶下标;然后把发生改变的元素迁移到新的位置; -
为什么hashmap的容量总是2的n次方?
计算桶下标17%16=1
等价于17-(17/16)*16=1
优化后17&(16-1)=2
优化后只涉及位运算和减法,其效率高于第一种方法;
如果不是2的n次方,则不能使用第二种优化算法; -
1.8之前hashmap多线程访问时发生了扩容,会发生什么现象?
- 会发生死链:链表头插法会颠倒原来一个散列桶里面链表的顺序,在并发的时候原来的顺序被另一个线程a颠倒了,而被挂起的线程b恢复后拿扩容前的节点和顺序继续完成第一次循环后,又遵循a线程扩容后的链表顺序重新排列链表中的顺序,最终形成环;
- 数据丢失
Hashmap源码分析
1. 链表的实现
Node是HashMap的一个内部类,实现了Map.Entry接口,本质就是一个映射;
//链表实现
static class Node<k,v> implements Map.Entry<k,v>{
final int hash;
final k key;
v value;
Node<k,v> next;
//构造函数 hash值,键,值,下一个节点
public Node(int hash, k key, v value, Node<k, v> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
//获取这个Node的key
@Override
public k getKey() {
return key;
}
//获取节点的value
@Override
public v getValue() {
return value;
}
//设置新的value值并返回旧的
@Override
public v setValue(v newValue) {
v oldValue=value;
value=newValue;
return oldValue;
}
//hashcode是key的hashcode值与上value的hashcode值
public final int hashCode(){
return Objects.hashCode(key)^Objects.hashCode(value);
}
public final String toString(){
return key+"="+value;
}
//判断两个node是否相等,若key和value都相等,返回true
public final boolean equals(Object o){
//与自身比较
if (o==this){
return true;
}
//判断o是否为Entry的实例
if(o instanceof Map.Entry){
//类型转换
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
//判断是否key和value都相等;
if(Objects.equals(key,e.getKey())&&Objects.equals(value,e.getValue())){
return true;
}
}
return false;
}
}
2. 红黑树TreeNode
比链表多了四个变量,parent、left、right、prev;
3. 位桶 Node<k,v>[ ] table
就是一条链表;
4. 类的继承关系
HashMap继承自父类AbstractMap,实现了Map、Cloneable,Serialzable接口;cloneable接口说明hashmap可以实现浅拷贝,Serializable表示hashmap实现了序列化,可以将hashmap对象保存至本地,之后可以恢复状态;
5. 类的属性
// 序列号
private static final long serialVersionUID = 362498820763181265L;
// 默认的初始容量是16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认的填充因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//若此时table的大小没有到默认的64,但是某个桶的节点数已经
//大于或等于8了,那么将这个桶转换为红黑树;
// 当桶(bucket)上的结点数大于这个值时会转成红黑树
static final int TREEIFY_THRESHOLD = 8;
// 当桶(bucket)上的结点数小于这个值时树转链表
static final int UNTREEIFY_THRESHOLD = 6;
//如果table的大小达到了64,则将所有桶都转换为红黑树
// 桶中结构转化为红黑树对应的table的最小大小
static final int MIN_TREEIFY_CAPACITY = 64;
// 存储元素的数组,总是2的幂次倍
transient Node<k,v>[] table;
// 存放具体元素的集
transient Set<map.entry<k,v>> entrySet;
// 存放元素的个数,注意这个不等于数组的长度。
transient int size;
// 每次扩容和更改map结构的计数器
transient int modCount;
// 临界值 当实际大小(容量*填充因子)超过临界值时,会进行扩容
int threshold;
// 填充因子
final float loadFactor;
6. 构造函数
- HashMap(int,float)型构造函数
public HashMap(int initialCapacity, float loadFactor) {
// 初始容量不能小于0,否则报错
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 初始容量不能大于最大值,否则为最大值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 填充因子不能小于或等于0,不能为非数字
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
// 初始化填充因子
this.loadFactor = loadFactor;
// 初始化threshold大小
this.threshold = tableSizeFor(initialCapacity);
}
tableSizeFor(initialCapacity)返回大于initialCapacity的最小的二次幂数值。
//根据期望容量cap,返回2的n次方形式的哈希桶的实际容量length
static final int tableSizeFor(int cap) {
//经过下面的 或 和 移位 运算 n组中各位都是1
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
//判断n是否越界,返回2的n次方作为table的阈值;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
- HashMap(int )型构造函数,只需传入map容量
public HashMap(int initialCapacity) {
// 调用HashMap(int, float)型构造函数
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
- HashMap() 型构造函数,默认容量,
public HashMap() {
// 初始化填充因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
- HashMap(Map<? extends K>)型构造函数
public HashMap(Map<? extends K, ? extends V> m) {
// 初始化填充因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 将m中的所有元素添加至HashMap中
putMapEntries(m, false);
}
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
// 如果当前表是空的
if (table == null) { // pre-size
// 根据m的元素数量和当前表的加载因子,计算出阈值
float ft = ((float)s / loadFactor) + 1.0F;
//修正阈值的边界 不能超过 最大容量MAXIMUM_CAPACITY
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
// 计算得到的新的阈值大于当前阈值,则返回一个新的阈值的满足2的n次方的阈值
if (t > threshold)
threshold = tableSizeFor(t);
}
// 已初始化,但是m元素个数大于阈值,进行扩容处理
else if (s > threshold)
resize();
// 将m中的所有元素添加至HashMap中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
7. 扩容 resize
作者:张旭童
来源:CSDN
原文:https://blog.csdn.net/zxt0601/article/details/77413921
版权声明:本文为博主原创文章,转载请附上博文链接!
final Node<K,V>[] resize() {
//oldTab 为当前表的哈希桶
Node<K,V>[] oldTab = table;
//当前哈希桶的容量 length
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//当前的阈值
int oldThr = threshold;
//初始化新的容量和阈值为0
int newCap, newThr = 0;
//如果当前容量大于0
if (oldCap > 0) {
//如果当前容量已经到达上限
if (oldCap >= MAXIMUM_CAPACITY) {
//则设置阈值是2的31次方-1
threshold = Integer.MAX_VALUE;
//同时返回当前的哈希桶,不再扩容
return oldTab;
}//否则新的容量为旧的容量的两倍。
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)//如果旧的容量大于等于默认初始容量16
//那么新的阈值也等于旧的阈值的两倍
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;//此时新表的容量为默认的容量 16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//新的阈值为默认容量16 * 默认加载因子0.75f = 12
}
if (newThr == 0) {//如果新的阈值是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) {
//取出当前的节点 e
Node<K,V> e;
//如果当前桶中有元素,则将链表赋值给e
if ((e = oldTab[j]) != null) {
//将原哈希桶置空以便GC
oldTab[j] = null;
//如果当前链表中就一个元素,(没有发生哈希碰撞)
if (e.next == null)
//直接将这个元素放置在新的哈希桶里。
//注意这里取下标 是用 哈希值 与 桶的长度-1 。 由于桶的长度是2的n次方,这么做其实是等于 一个模运算。但是效率更高
newTab[e.hash & (newCap - 1)] = e;
//如果发生过哈希碰撞 ,而且是节点数超过8个,转化成了红黑树(暂且不谈 避免过于复杂, 后续专门研究一下红黑树)
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//如果发生过哈希碰撞,节点数小于8个。则要根据链表上每个节点的哈希值,依次放入新哈希桶对应下标位置。
else { // preserve order
//因为扩容是容量翻倍,所以原链表上的每个节点,现在可能存放在原来的下标,即low位, 或者扩容后的下标,即high位。 high位= low位+原哈希桶容量
//低位链表的头结点、尾节点
Node<K,V> loHead = null, loTail = null;
//高位链表的头节点、尾节点
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;//临时节点 存放e的下一个节点
do {
next = e.next;
//这里又是一个利用位运算 代替常规运算的高效点: 利用哈希值 与 旧的容量,可以得到哈希值去模后,是大于等于oldCap还是小于oldCap,等于0代表小于oldCap,应该存放在低位,否则存放在高位
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);
//将低位链表存放在原index处,
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//将高位链表存放在新index处
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}