1 核心知识点
- 底层数据存储结构
- 初始化容量
- 扩容机制
- 线程安全
- 时间复杂度
2 关键代码分析
- 底层数据结构
敲黑板：数组+链表+红黑树
先了解底层的数据存储结构，在HashMap内部有table属性
transient Node<K,V>[] table;
可以看到table属性是一个Node数组，那么这个Node又是怎么样一个对象呢
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
Nodd是HashMap里面的一个静态内部类，里面有四个属性
hash:用来记录key的哈希值
key:记录存储元素的key
value:记录存储元素的value值
next:应用于链表数据结构，当元素数量增加的时候，如果一直保持数组结构，会影响HashMap的存储效率，所以这个元素链表结构需要记录的下一个元素的指针
- put方法详解
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
这里关注一下hash(key)这个计算key的hash值的方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
- 判断key是不是为null，如果为null，key的hash值为0，这里说明HashMap的key是可以为null的，。
- 如果不为0，则用key的hash值和key值的右移16位的结果进行^计算。这里的原理是，hash值是存在一定概率的冲突的，而我们在计算元素在Node数组中的存储索引的时候，是通过i = (n - 1) & hash�这个方式计算，这里的n就是数组的容量大小，n一般不会超过2的16次方65536，也就是1<<<16的结果，所以 (n - 1) & hash�进行&计算的时候，高16位是没有参与计算的，为了降低hash冲突，于是把高16位也作为变量因子参与hash值的计算，即h = key.hashCode()) ^ (h >>> 16)。
看看关键方法putVal
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 步骤1
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 步骤2
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 步骤3
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 步骤4
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;
}
步骤1：如果table==null或者table.size==0，代表存储结构table数组还没初始化，调用resize方法进行容量初始化，主要包含两部分，先确定要扩容的大小，然后初始化扩容后的存储结构
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
// 原来的容量大小
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 原来的阈值，默认cap*loadFactor（0.75）即容量大小*0.75
int oldThr = threshold;
int newCap, newThr = 0;
// 先判断容量是否>0，意思就是容量已经初始化过了
if (oldCap > 0) {
// 如果超过最大容量长度，则长度最大是MAXIMUM_CAPACITY=1 << 30，即2的30次方
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 { // 没有初始化过，初始化为默认值，容量为16，阈值为16*0.75=12
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;
}
**步骤2：**计算需要存储元素的索引位置，如果table数组中该索引位置为空，那么就将该元素放入数组中索引的位置
步骤3：如果索引位置已经有元素，且key的值也相等，那么新元素存储到这个索引位置，覆盖掉原来的元素
步骤4: 如果索引位置已经有元素且key的值也不相等，那么就判断此处是否为树结构，如果是树结构，那么将元素以树的形式存储，否则以链表的形式存储，如果链表长度>8，将该位置的存储结构转化为树
3 线程安全
- 非线程安全的
场景A
有两个线程A和B，A线程向HashMap中插入(key-A,value-A)，B线程向HashMap中插入(key-B,value-B)通过索引计算，通过hash计算后，key-A和key-B的值都为3，但是key-A.equals(key-B)为false，也就是说值不相等，那么都会往table[3]的位置插入，假设线程A和B同时执行，此时都通过
if ((p = tab[i = (n - 1) & hash]) == null)
判断为true，都走进了条件逻辑，执行下面的赋值逻辑
tab[3] = newNode(hash, key, value, null);
假设线程A先执行，将tab[3]赋值乘value-A，但是接下来线程B立马将tab[3]又赋值成了value-B，将线程A的值覆盖掉了
- 线程安全怎么做
- 使用HashTable(不推荐，性能太低)
- 使用Collection.synchronizedMap(不推荐，性能太低)
- 使用ConcurrentHashMap（推荐）
4 面试技巧
面试问题：说说HashMap的底层原理和设计？
这个问题考察的不仅仅是对源码的熟悉程度，同时也是对源码阅读能力的考察，大部分人，只能够按照网上教的八股文进行回答，比如数据结构，数组，链表以及红黑树结构设计，扩容机制，扩容因子，初始容量等知识点。
高亮回答，讲一讲扩容算法？
- hash值计算的细节
key的hashcode值和key的高16位进行异或操作，因为大多数key的hashcode值在进行取模进行索引计算的时候，只使用到了后16位，因为一般的存储hashMap的容量不会超过16位，所以要让key的高16位参与到hash值的计算当中，降低hash冲突。
- 扩容是2的倍数有什么好处
在进行索引位进行计算的时候，如果是2的倍数，在进行索引取模进行计算的时候，可以利用位运算进行取模，加快计算速度，提升性能。
- 线程安全带来的具体问题以及实现线程安全有哪些方法
多线程操作同一个hashmap对象，会导致同一个索引位的值会被另一个线程的值覆盖，如果要实现线程安全，建议通过ConcurrentHashMap对象，在保证线程安全的同时，在性能上也有一定的保障。
- 详细阐述数组，链表，红黑树的时间复杂度
本文由博客一文多发平台 OpenWrite 发布！
