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;
}