前言
空杯心态
一代武学宗师,功夫巨星李小龙也非常推崇这句话,他说:“清空你的杯子,方能再行注满,空无以求全。”
空杯心态就是对过去荣耀、挫折的一种舍弃,也是对自己的一种否定,舍得之后才能获得更多,否定自己需要很大的勇气,但唯有如此才能找到自己的差距和不足,找到应该努力的方向。一个人应该舍弃的东西很多,懒惰、得过且过的混日子思想自然是不行的、是最应舍弃的。
人生是一场盛宴,绝不只是一道好菜。不能因小小的成绩就得意忘形,或者甘于认命。尤其是当我们还是青年的时候,更要学会空杯,既不能因一时的失败或挫折而一蹶不振,更不能因小小的成绩而得意忘形,我们要时刻“空杯”,勇于放下,这样才能取得更好的成绩,才能在今后的道路上走得更稳、更远!
源码分析
构造函数
public HashMap(int initialCapacity, float loadFactor) {
//初始容量不能<0
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//初始容量不能 > 最大容量值,HashMap的最大容量值为2^30
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//负载因子不能 < 0
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
// 计算出大于 initialCapacity 的最小的 2 的 n 次方值。
this.threshold = tableSizeFor(initialCapacity);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
对象
/**
* Node是单向链表,它实现了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值 键 值 下一个节点
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
/**
* 红黑树
*/
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // 父节点
TreeNode<K,V> left; // 左节点
TreeNode<K,V> right; // 右节点
TreeNode<K,V> prev; // 删除后需要取消节点,指向上一个同级节点
boolean red; // 颜色属性
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
}
静态变量
/**
* 默认的初始容量是16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认的负载因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 当桶(bucket)上的结点数大于这个值时会转成红黑树
* 隐藏条件:table size >= 64才会转成红黑树,否则只是扩容
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 当桶(bucket)上的结点数小于这个值时树转链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 桶(bucket)中结构转化为红黑树对应的table的最小大小
*/
static final int MIN_TREEIFY_CAPACITY = 64;
成员变量
/**
* 存储元素的数组,总是2的幂次倍
*/
transient Node<K,V>[] table;
/**
* 存放具体元素的集
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 存放元素的个数
* 注意:这个不等于数组的长度。
*/
transient int size;
/**
* Hashmap被修改、或者被删除的次数
* 快速失败 modCount == table.length
*/
transient int modCount;
/**
* 临界值 当集合内元素超过临界值时(容量*填充因子),会进行扩容
*/
int threshold;
/**
* 负载因子
*/
final float loadFactor;
方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods.
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
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;
}
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* Implements Map.get and related methods.
*
* @param hash hash for key
* @param key the key
* @return the node, or null if none
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
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
newCap = DEFAULT_INITIAL_CAPACITY;
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;
@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) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
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);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
面试问答
1、hashmap的数据结构、hashmap的底层原理
小伙子你了解数据结构中的HashMap么?能跟我聊聊他的结构和底层原理么?
嗯嗯面试官,我知道HashMap是我们非常常用的数据结构,由数组和链表组合构成的数据结构。
大概如下,数组里面每个地方都存了Key-Value这样的实例,在Java7叫Entry在Java8中叫Node。
数组初始化的时候,所有位置的元素都是null,在put插入的时候会根据key的hash去计算index值。
比如我put(”变形金刚“,520),那这个key的hash结果是 (“变形金刚”)= 2,那数组下标就是2
在get的时候也是根据key的hash去计算index的值,将对象取出来。
ps:
put的时候会返回值,数组所有位置都是null,无法区分是此位置无值和put的null值。
index值的结果范围是 0~map.size-1。
你提到了还有链表,为啥需要链表,链表又是怎么样子的呢?
我们都知道数组长度是有限的,在有限的长度里面我们使用哈希,哈希本身就存在概率性,就是”帅丙“和”丙帅“我们都去hash有一定的概率会一样,就像上面的情况我再次哈希”丙帅“极端情况也会hash到一个值上,那就形成了链表。
每一个节点都会保存自身的hash、key、value、以及下个节点,我看看Node的源码。
说到链表我想问一下,你知道新的Entry节点在插入链表的时候,是怎么插入的么?
java8之前是头插法,就是说新来的值会取代原有的值,原有的值就顺推到链表中去,就像上面的例子一样,因为写这个代码的作者认为后来的值被查找的可能性更大一点,提升查找的效率。
但是,在java8之后,都是所用尾部插入了。
为啥改为尾部插入呢?
首先我们看下HashMap的扩容机制:
帅丙提到过了,数组容量是有限的,数据多次插入的,到达一定的数量就会进行扩容,也就是resize。
什么时候resize呢?
有两个因素:
- Capacity:HashMap当前长度。
- LoadFactor:负载因子,默认值0.75f。
怎么理解呢,就比如当前的容量大小为16,当你存进第13个的时候,判断发现需要进行resize了,那就进行扩容,但是HashMap的扩容也不是简单的扩大点容量这么简单的。
扩容?它是怎么扩容的呢?
分为两步
- 扩容:创建一个新的Entry空数组,长度是原数组的2倍。
- ReHash:遍历原Entry数组,把所有的Entry重新Hash到新数组。
ReHash:遍历原Entry数组,把所有的Entry重新Hash到新数组。
是因为长度扩大以后,Hash的规则也随之改变。
Hash的公式—> index = HashCode(Key) & (Length - 1)
原来长度(Length)是8你位运算出来的值是2 ,新的长度是16你位运算出来的值明显不一样了。
扩容前:
扩容后:
说完扩容机制我们言归正传,为啥之前用头插法,java8之后改成尾插了呢?
卧槽,我以为她忘记了!居然还是被问到了!
我先举个例子吧,我们现在往一个容量大小为2的put两个值,负载因子是0.75是不是我们在put第二个的时候就会进行resize?
2*0.75 = 1 所以插入第二个就要resize了
.现在我们要在容量为2的容器里面用不同线程插入A,B,C,假如我们在resize之前打个短点,那意味着数据都插入了但是还没resize那扩容前可能是这样的。
我们可以看到链表的指向A->B->C
Tip:A的下一个指针是指向B的
因为resize的赋值方式,也就是使用了单链表的头插入方式,同一位置上新元素总会被放在链表的头部位置,在旧数组中同一条Entry链上的元素,通过重新计算索引位置后,有可能被放到了新数组的不同位置上。
就可能出现下面的情况,大家发现问题没有?
B的下一个指针指向了A
一旦几个线程都调整完成,就可能出现环形链表
如果这个时候去取值,悲剧就出现了——Infinite Loop(无限循环)。
小伙子有点东西呀,但是你都都说了头插是JDK1.7的那1.8的尾插是怎么样的呢?
因为java8之后链表有红黑树的部分,大家可以看到代码已经多了很多if else的逻辑判断了,红黑树的引入巧妙的将原本O(n)的时间复杂度降低到了O(logn)。
Tip:红黑树的知识点同样很重要,还是那句话不打没把握的仗,限于篇幅原因,我就不在这里过多描述了,以后写到数据结构再说吧,不过要面试的仔,还是要准备好,反正我是经常问到的。
使用头插会改变链表的上的顺序,但是如果使用尾插,在扩容时会保持链表元素原本的顺序,就不会出现链表成环的问题了。
就是说原本是A->B,在扩容后那个链表还是A->B
Java7在多线程操作HashMap时可能引起死循环,原因是扩容转移后前后链表顺序倒置,在转移过程中修改了原来链表中节点的引用关系。
Java8在同样的前提下并不会引起死循环,原因是扩容转移后前后链表顺序不变,保持之前节点的引用关系。
那是不是意味着Java8就可以把HashMap用在多线程中呢?
我认为即使不会出现死循环,但是通过源码看到put/get方法都没有加同步锁,多线程情况最容易出现的就是:无法保证上一秒put的值,下一秒get的时候还是原值,所以线程安全还是无法保证。
那我问你HashMap的默认初始化长度是多少?
我记得我在看源码的时候初始化大小是16
你那知道为啥是16么?
在JDK1.8的 236 行有1<<4就是16,为啥用位运算呢?直接写16不好么?
为啥我们重写equals方法的时候需要重写hashCode方法呢?
你能用HashMap给我举个例子么?
因为在java中,所有的对象都是继承于Object类。Ojbect类中有两个方法equals、hashCode,这两个方法都是用来比较两个对象是否相等的。
在未重写equals方法我们是继承了object的equals方法,那里的 equals是比较两个对象的内存地址,显然我们new了2个对象内存地址肯定不一样
- 对于值对象,==比较的是两个对象的值
- 对于引用对象,比较的是两个对象的地址
大家是否还记得我说的HashMap是通过key的hashCode去寻找index的,那index一样就形成链表了,也就是说”帅丙“和”丙帅“的index都可能是2,在一个链表上的。
我们去get的时候,他就是根据key去hash然后计算出index,找到了2,那我怎么找到具体的”帅丙“还是”丙帅“呢?
equals!是的,所以如果我们对equals方法进行了重写,建议一定要对hashCode方法重写,以保证相同的对象返回相同的hash值,不同的对象返回不同的hash值。
不然一个链表的对象,你哪里知道你要找的是哪个,到时候发现hashCode都一样,这不是完犊子嘛。
可以可以小伙子,我记得你上面说过他是线程不安全的,那你能跟我聊聊你们是怎么处理HashMap在线程安全的场景么?
面试官,在这样的场景,我们一般都会使用HashTable或者ConcurrentHashMap,但是因为前者的并发度的原因基本上没啥使用场景了,所以存在线程不安全的场景我们都使用的是ConcurrentHashMap。
HashTable我看过他的源码,很简单粗暴,直接在方法上锁,并发度很低,最多同时允许一个线程访问,ConcurrentHashMap就好很多了,1.7和1.8有较大的不同,不过并发度都比前者好太多了。
put过程
在第一次put的时候 触发一次resize()方法进行扩容,new一个Node数组,默认值就是长度16 负载因子0.75 扩容阈值12。
有三种情况:
1、元素位置 是null,直接放入
2、元素位置 有值,hash和equals相同 覆盖旧值
3、元素位置 有值,hash相同equals不相同,循环链表在尾部插入。
3.1、数组长度小于64,链表长度等于8 进行扩容
3.2、数组长度大于等于64,链表长度等于8,链表转红黑树
红黑树转链表
1、remove()执行后,红黑树长度等于6,转链表
2、resize()执行后,红黑树长度等于6,转链表
put (null, null)
key为null的时候,hash返回0,插入tab[] 数组头部
modCount 变量的作用
迭代集合的时候会用到,用来记录迭代次数,当迭代次数modCount和size不一致的时候,返回快速失败。
详解
静态变量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
DEFAULT_INITIAL_CAPACITY 初始化集合长度,必须是2的次幂,默认值16.
1、为什么必须是2的次幂?
- &(与)运算速度快,至少比%取模运算块
- 能保证 索引值 肯定在 capacity 中,不会超出数组长度
- (n - 1) & hash,当n为2次幂时,会满足一个公式:(n - 1) & hash = hash % n
当向 HashMap 中添加一个元素的时候,需要根据 key 的 hash 值,去确定其在数组中的具体位置。HashMap 为了存取高效,减少碰撞,就是要尽量把数据分配均匀,每个桶长度大致相同,这个实现的关键就在把数据存到哪个桶中的算法。
这个算法实际就是取模,hash % length,计算机中直接求余效率不如位移运算。所以源码中做了优化,使用 hash & (length - 1),而实际上 hash % length 等于 hash & (length - 1) 的前提是 length 是 2 的 n 次幂。
例如长度为 8 的时候,3 & (8 - 1) = 3,2 & (8 - 1) = 2,不同位置上,不碰撞。
当集合长度是2的次幂,可以使用tableSizeFor方法 位移计算快速算出结果。
实例化HashMap时带参数时,会根据参数调整table的大小,假设参数为100,最终会调整成256,确保table的大小总是2的幂次方
/**
* Returns a power of two size for the given target capacity.
*/
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、如果输入值不是 2 的幂比如 10 会怎么样?
正常使用但是影响效率,因为满足不了 (n - 1) & hash = hash % n 公式,使用 (n - 1) & hash 来计算桶位置。
static final int MAXIMUM_CAPACITY = 1 << 30;
最大容量为 2的30次幂
static final float DEFAULT_LOAD_FACTOR = 0.75f;
负载因子可以调整hash碰撞和resize扩容的参数
1、为什么是0.75?
0.75是由泊松公式计算出的结果,在hash冲突和扩容之间找了一个平衡点。
负载因子太小了浪费空间并且会发生更多次数的resize,太大了哈希冲突增加会导致性能不好,所以0.75只是一个折中的选择,可以根据具体场景调整到最优。
static final int TREEIFY_THRESHOLD = 8;
当数组的某个链表的长度>=8时,链表结构会转换成红黑树结构(还要求桶的中数量>=64)
static final int UNTREEIFY_THRESHOLD = 6;
当红黑树中的节点数量<=6时,红黑树结构会转变为链表结构
1、为什么大于8才会转红黑树?
根据泊松分布,在负载因子默认为0.75的时候,单个hash槽内元素个数为8的概率小于百万分之一,所以将7作为一个分水岭,等于7的时候不转换,大于等于8的时候才进行转换,小于等于6的时候就化为链表。
2、为什么小于6才会转链表?
在执行resize的时候(元素位置重新计算)当红黑树里的元素少于6个会将红黑树转为链表
小于7转链表的话,当增加和减少1个数据的情况频繁,链表与红黑树一直在互转也会影响性能,间隔2是为了避免这种转换频繁发生。
static final int MIN_TREEIFY_CAPACITY = 64;
1、这个值的作用是什么?
最小树形化容量阈值:即 当哈希表中的容量 > 该值时,才允许树形化链表 (即 将链表 转换成红黑树)
// 否则,若链表内元素太多时,则直接扩容,而不是树形化
// 为了避免进行扩容、树形化选择的冲突,这个值不能小于 4 * TREEIFY_THRESHOLD
成员变量
transient Node<K,V>[] table;
往map中put的(k,v)都被封装在Node中,所有的Node都存放在table数组中。
第一个Node存在table[]数组中,第二个Node的地址 记录在 第一个Node的next属性中
final int hash;
final K key;
V value;
Node<K,V> next;
transient Set<Map.Entry<K,V>> entrySet;
用于返回keySet和values
transient int size;
保存当前tab数组中有多少个元素
transient int modCount;
集合迭代次数,在循环的时候会用到。
主要用于标识线程安全,即map只能在单线程环境下使用,在多线程环境下会出现并发安全问题,modCount主要用于记录对map的修改次数,如果一个线程操作期间modCount发生了变化。即有多个线程同时修改当前这个map,此时会抛“ConcurrentModificationException”异常,这又被称为“failFast机制”,在很多非线程安全的类中都有failFast机制:ArrayList、
LinkedList等。这个机制主要用于迭代器、加强for循环等相关功能,也就是一个线程在迭代一个容器 时,如果其他线程改变了容器内的元素,迭代的这个线程会抛 出“ConcurrentModificationException”异常
int threshold;
扩容阈值,公式 capacity * load factor 计算得出
final float loadFactor;
负载因子,自定义map时用这个,未定义则用默认0.75