文章目录
- 一、List相关面试题
- 二、HashMap相关面试题
- 2.1 红黑树、散列表
- 2.2 HashMap源码分析（底层实现）
- 2.3 说一下HashMap的实现原理
- 2.4 HashMap的jdk1.7和jdk1.8有什么区别
- 2.5 HashMap的put方法的具体流程
- 2.6 讲一讲HashMap的扩容机制
- 2.7 hashMap的寻址算法
- 2.8 为什么我们需要hash()函数 (n-1)&hash，而不是直接用key的hashcode直接计算下标
- 2.9 为何HashMap的数组长度一定是 2^n 次幂？
- 2.10 hashmap在1.7情况下的多线程死循环问题
- 2.11 为什么经常使用String作为HashMap的Key
- 2.12 HashMap与Hashtable的区别
一、List相关面试题
1.1 ArrayList源码分析（底层实现）
我们分析源码 主要从以下几个方面来考虑：成员变量、构造函数、关键方法。
以下源码都来自于 jdk1.8
- ArrayList成员变量
//默认初始的容量(CAPACITY)
private static final int DEFAULT_CAPACITY = 10;
//用于空实例的共享空数组实例
private static final Object[] EMPTY_ELEMENTDATA = {};
//用于默认大小的空实例的共享空数组实例
//我们将其与 EMPTY_ELEMENTDATA 区分开来，以了解添加第一个元素时要膨胀多少
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//存储 ArrayList 元素的数组缓冲区（真正存放元素的数组）。 ArrayList 的容量就是这个数组缓冲区的长度
//当添加第一个元素时，任何具有 elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的空 ArrayList都将扩展为 DEFAULT_CAPACITY，当前对象不参与序列化
transient Object[] elementData;
//ArrayList 的大小（它包含的元素数量）
private int size;
- ArrayList构造函数
//带初始化容量的构造函数
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
//无参构造函数，默认创建空集合
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//将collection对象转换成数组，然后将数组的地址的赋给elementData
public ArrayList(Collection<? extends E> c) {
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
- ArrayList 添加和扩容操作
第1次添加数据、第2至10次添加数据、第11次添加数据
核心步骤：
-
利用空参创建的集合，在底层创建一个长度为0的数组。数组名字：elementDate，定义变量size。
size这个变量有两层含义：①元素的个数，也就是集合的长度；②下一个元素的存入位置
-
添加第一个元素时，底层会创建一个新的长度为10的数组。添加完毕后，size++
-
存满时，会扩容1.5倍（扩容时机一：当存满时候，会创建一个新的数组，新数组的长度 是原来的1.5倍，也就是长度为15。再把所有的元素，全拷贝到新数组中。如果继续添加数据，这个长度为15的数组也满了，那么下次还会继续扩容，还是1.5倍）
-
如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准（扩容时机二）
举个例子：在一开始，如果默认的长度为10的数组已经装满了，在装满的情况下，我一次性要添加100个数据 addAll，很显然 10扩容1.5倍 变成15，还是不够，怎么办？ ——> 此时新数组的长度，就以实际情况为准，就是110（100+10）
1.2 ArrayList底层的实现原理是什么
- 底层数据结构：ArrayList底层是用动态的数组实现的
- 初始容量：ArrayList初始容量为0，当第一次添加数据的时候才会初始化容量为10（默认初始化值为null）
- 扩容逻辑：ArrayList在进行扩容的时候是原来容量的1.5倍，每次扩容都需要拷贝数组
- 添加逻辑
- 确保数组已使用长度（size）加1之后足够存下下一个数据
- 计算数组的容量，如果当前数组已使用长度+1后的大于当前的数组长度，则调用grow方法扩容（原来的1.5倍）
- 确保新增的数据有地方存储之后，则将新元素添加到位于size的位置上
- 返回添加成功布尔值。
1.3 ArrayList list=new ArrayList(10)中的list扩容几次
该语句只是声明和实例了一个ArrayList，指定了容量为10，未扩容。
/**
* 构造一个具有指定初始容量的空列表
* 参数：initialCapacity - 列表的初始容量
* 抛出：IllegalArgumentException – 如果指定的初始容量为负
*/
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
1.4 如何实现数组和List之间的转换
- 数组转List，使用JDK中java.util.Arrays工具类的asList方法
- List转数组，使用List的toArray方法。无参toArray方法返回 Object数组；传入初始化长度的数组对象，返回该对象数组
//数组转List
public static void testArray2List() {
String[] strs = {"money", "health", "honor"};
List<String> list = Arrays.asList(strs);
for (String s : list) {
System.out.println(s);
}
System.out.println(list); //[money, health, honor]
}
//List转数组
public static void testList2Array() {
List<String> list = new ArrayList<>();
list.add("money");
list.add("health");
list.add("honor");
String[] array = list.toArray(new String[list.size()]);
for (String s : array) {
System.out.println(s);
}
System.out.println(list);
}
面试官再问：
- 用Arrays.asList转List后，如果修改了数组内容，list受影响吗
- 受影响。Arrays.asList转换list之后，如果修改了数组的内容，list会受影响，因为它的底层使用的Arrays类中的一个内部类ArrayList来构造的集合，在这个集合的构造器中，把我们传入的这个集合进行了包装而已，最终指向的都是同一个内存地址
- List用toArray转数组后，如果修改了List内容，数组受影响吗
- 不受影响。list用了toArray转数组后，如果修改了list内容，数组不会影响，当调用了toArray以后，在底层是它是进行了数组的拷贝，跟原来的元素就没啥关系了，所以即使list修改了以后，数组也不受影响
//受影响
public static void testArray2List() {
String[] strs = {"money", "health", "honor"};
List<String> list = Arrays.asList(strs);
for (String s : list) {
System.out.println(s);
}
strs[1] = "study";
System.out.println("======");
System.out.println(list); //[money, study, honor]
}
//不受影响
public static void testList2Array() {
List<String> list = new ArrayList<>();
list.add("money");
list.add("health");
list.add("honor");
String[] array = list.toArray(new String[list.size()]);
for (String s : array) {
System.out.println(s);
}
list.set(1, "study");
System.out.println("======");
for (String s : array) {
System.out.println(s); // money health honor
}
}
1.5 ArrayList 和 LinkedList 的区别是什么
1）底层数据结构
- ArrayList 是动态数组的数据结构实现
- LinkedList 是双向链表的数据结构实现
2）操作数据效率
- ArrayList按照下标查询的时间复杂度O(1)【内存是连续的，根据寻址公式】， LinkedList不支持下标查询
- 查找（未知索引）： ArrayList需要遍历，链表也需要链表，时间复杂度都是O(n)
- 新增和删除：
- ArrayList尾部插入和删除，时间复杂度是O(1)；其他部分增删需要挪动数组，时间复杂度是O(n)
- LinkedList头尾节点增删时间复杂度是O(1)，其他都需要遍历链表，时间复杂度是O(n)
3）内存空间占用
- ArrayList底层是数组，内存连续，节省内存
- LinkedList 是双向链表需要存储数据，和两个指针，更占用内存
4）线程安全
-
ArrayList和LinkedList都不是线程安全的
-
如果需要保证线程安全，有两种方案：
- 在方法内使用，局部变量则是线程安全的
- 使用线程安全的ArrayList和LinkedList
List<Object> syncArrayList = Collections.synchronizedList(new ArrayList<>()); List<Object> syncLinkedList = Collections.synchronizedList(new LinkedList<>());
~~~
补充 单向链表、双向链表：
- 单向链表：只有一个方向，结点只有一个后继指针 next
- 查询：只有在查询头节点的时候不需要遍历链表，时间复杂度是O(1)；查询其他结点需要遍历链表，时间复杂度是O(n)
- 插入/删除操作：只有在添加和删除头节点的时候不需要遍历链表，时间复杂度是O(1)；添加或删除其他结点需要遍历链表找到对应节点后，才能完成新增或删除节点，时间复杂度是O(n)
- 双向链表：支持两个方向，每个结点不止有一个后继指针next指向后面的结点，还有一个前驱指针prev指向前面的结点
- 查询：查询头尾结点的时间复杂度是O(1)，给定节点找前驱节点的时间复杂度为O(1)，平均的查询时间复杂度是O(n)
- 增删操作：头尾结点增删的时间复杂度为O(1)，给定节点增删的时间复杂度为O(1)，其他部分结点增删的时间复杂度是 O(n)
| 查询 | 新增删除 | |
|---|---|---|
| 单向链表 | 头O(1)，其他O(n) | 头O(1)，其他O(n) |
| 双向链表 | 头尾O(1)，其他O(n)，给定节点O(1) | 头尾O(1)，其他O(n)，给定节点O(1) |
二、HashMap相关面试题
在HashMap中的最重要的一个数据结构就是散列表，在散列表中又使用到了红黑树和链表。
2.1 红黑树、散列表
2.1.1 红黑树
-
红黑树：一颗自平衡的二叉搜索树（BST），所有的红黑规则都是希望红黑树能够保证平衡。红黑规则如下：
- 每一个节点或是红色的，或者是黑色的
- 根节点必须是黑色
- 如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为叶节点，每个叶节点(Nil)是黑色的空节点
- 如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情况)
- 对每一个节点,从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点
-
查找、添加、删除的时间复杂度都是O(n)。
2.1.2 散列表
（散列表的概念、散列函数、散列冲突、拉链法）
1）散列表（Hash Table）：又名哈希表/Hash表，是根据键（Key）直接访问在内存存储位置值（Value）的数据结构，它是由数组演化而来的，利用了数组支持按照下标进行随机访问数据的特性。
假设有100个人参加马拉松，不采用1-100的自然数对选手进行编号，编号有一定的规则比如：2023ZHBJ001，其中2023代表年份，ZH代表中国，BJ代表北京，001代表原来的编号，那此时的编号2023ZHBJ001不能直接作为数组的下标，此时应该如何实现呢？
2）散列冲突：也叫哈希冲突、哈希碰撞，指多个key映射到同一个数组下标位置
3）散列冲突-链表法（拉链）：在散列表中，数组的每个下标位置我们可以称之为桶（bucket）或者槽（slot），每个桶(槽)会对应一条链表，所有散列值相同的元素我们都放到相同槽位对应的链表中。时间复杂度如下
- 插入操作：O(1)。通过散列函数计算出对应的散列槽位，将其插入到对应链表中即可
- 当查找、删除一个元素时，我们同样通过散列函数计算出对应的槽，然后遍历链表查找或者删除
- 平均情况下基于链表法解决冲突时查询的时间复杂度是O(1)
- 散列表可能会退化为链表,查询的时间复杂度就从 O(1) 退化为 O(n)
- 将链表法中的链表改造为其他高效的动态数据结构，比如红黑树，查询的时间复杂度是 O(logn)
2.2 HashMap源码分析（底层实现）
我们分析源码 主要从以下几个方面来考虑：成员变量、构造函数、关键方法。
2.2.1 HashMap成员变量
//默认的初始容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//最大数量，该数组最大值为2^30。
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的加载因子。如果构造的时候不传则为0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//一个位置里存放的节点转化成树的阈值，也就是8，比如数组里有一个node，这个node链表的长度达到该值才会转化为红黑树。
static final int TREEIFY_THRESHOLD = 8;
//当一个反树化的阈值，当这个node长度减少到该值就会从树转化成链表
static final int UNTREEIFY_THRESHOLD = 6;
//满足节点变成树的另一个条件，就是存放node的数组长度要达到64
static final int MIN_TREEIFY_CAPACITY = 64;
//具体存放数据的数组！！！
transient Node<K,V>[] table; //见下
//entrySet，一个存放k-v缓冲区
transient Set<Map.Entry<K,V>> entrySet;
//size是指hashMap中存放了多少个键值对
transient int size;
//对map的修改次数
transient int modCount;
//The next size value at which to resize (capacity * load factor).
int threshold;
//加载因子
final float loadFactor;
//链表中的键值对对象
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;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
//红黑树中的键值对对象
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;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* Returns root of tree containing this node.
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
//...
}
注意HashMap中的 transient Node<K,V>[] table，该table是真正存放数据的容器，该容器由一个又一个node组成，而node有三种实现，所以hashMap中存放的node的形式既可以是Node也可以是TreeNode。可见HashMap是基于数组、链表或者树实现的。
【HashMap 的定义是一个散列表，这是一种支持快速查找元素的数据结构，那么其背后就必然会使用到数组随机访问的特点。因此，HashMap 的一维结构就是一个数组，数组元素是一个包含 Key、Value 和 hashcode 的 Entry 节点。当我们需要访问集合元素时，其实就是先通过 key 计算 hashcode，再将 hashCode 对数组长度取余得到数组下标，最后通过下标去数组中找到对应的 Value】
DEFAULT_INITIAL_CAPACITY 默认的初始容量
DEFAULT_LOAD_FACTOR 默认的加载因子
扩容阈值 == 数组容量 * 加载因子
2.2.2 HashMap构造函数
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//当容量大于2^31就取最大值1<<31;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//当前数组table的大小，一定是2的幂次方
// tableSizeFor保证了数组一定是2的幂次方，是大于initialCapacity最接近的值。
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);
}
HashMap是懒惰加载，在创建对象时并没有初始化数组；在无参的构造函数中，设置了默认的加载因子是0.75。
构造方法一共重载了四个，主要初始化了三个参数：
-
initialCapacity 初始容量（默认16）： hashMap底层由数组实现+链表（或红黑树）实现，但是还是从数组开始，所以当储存的数据越来越多的时候，就必须进行扩容操作，如果在知道需要储存数据大小的情况下，指定合适的初始容量，可以避免不必要的扩容操作，提升效率
-
threshold 阈值：hashMap所能容纳的最大价值对数量，如果超过则需要扩容，计算方式：threshold=initialCapacity*loadFactor（构造方法中直接通过tableSizeFor(initialCapacity)方法进行了赋值，主要原因是在构造方法中，数组table并没有初始化，put方法中进行初始化，同时put方法中也会对threshold进行重新赋值，这个会在后面的源码中进行分析）
-
loadFactor 加载因子（默认0.75）：当负载因子较大时，去给table数组扩容的可能性就会少，所以相对占用内存较少（空间上较少），但是每条entry链上的元素会相对较多，查询的时间也会增长（时间上较多）。反之就是，负载因子较少的时候，给table数组扩容的可能性就高，那么内存空间占用就多，但是entry链上的元素就会相对较少，查出的时间也会减少。所以才有了负载因子是时间和空间上的一种折中的说法。所以设置负载因子的时候要考虑自己追求的是时间还是空间上的少。（一般情况下不需要设置，系统给的默认值已经比较适合了）
我们最常使用的是无参构造，在这个构造方法里面仅仅设置了加载因子为默认值，其他两个参数会在resize方法里面进行初始化，在这里知道这个结论就可以了，下面会在源码里面进行分析； 另外一个带有两个参数的构造方法，里面对初始容量和阈值进行了初始化，对阈值的初始化方法为 tableSizeFor(int cap),看一下源码：
//找到大于或等于 cap 的最小2的幂
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;
}
tableSizeFor()方法保证了数组大小一定是2的幂次方,是如何实现的呢？ —— 该方法将一个二进制数第一位1后边的数字全部变成1，然后再加1，这样这个二进制数就一定是100…这样的形式。此处实现在ArrayDeque的实现中也用到了类似的方法来保证数组长度一定是2的幂次方。
对于无符号右移运算符不了解的，可以看一下这篇文章了解一下，下面偷一张图 以10为例进行分析：
另外，需要注意一下的是，第一步 int n = cap - 1; 这个操作，执行这个操作的主要原因是为了防止在cap已经是2的n次幂的情况下，经过运算后得到的结果是cap的二倍的结果，例如如果n为l6，经过一系列运算之后，得到的结果是0001 1111，此时最后一步n+1 执行之后，就会返回32，有兴趣的可以自己进行尝试
2.2.3 HashMap关键方法
2.2.3.1 put方法
在hashMap源码中，put方法逻辑是最为复杂的，接下来先看一下源码：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//tab 局部变量，用来记录哈希表中数组的地址值（成员变量table放在堆中，方法放在栈中，如果一直调用table 需要反复去堆中获取，故定义tab）
//p 临时的第三方变量，用来记录键值对对象的地址值；n 表示当前数组的长度；i 表示索引
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
//resize()方法逻辑：
//1.如果当前是第一次添加数据，底层会创建一个默认长度为16、加载因子为0.75的数组
//2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容的条件：如果没有达到扩容条件，底层不会做任何操作；如果达到了扩容条件，底层会把数组扩容为原先的两倍，并把数据全部转移到新的哈希表中
n = (tab = resize()).length;
// i = (n - 1) & hash 拿着数组长度与键的哈希值进行计算，得出当前键值对对象 在数组中应存入的位置
if ((p = tab[i = (n - 1) & hash]) == null)
//通过hash找到下标，如果hash值指定的位置数据为空，则创建一个键值对对象，直接放到数组中
tab[i] = newNode(hash, key, value, null);
else {
//如果通过hash找到的位置有数据，发生碰撞
Node<K,V> e; K k;
//p.hash == hash 判断键是否一样
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//如果需要插入的key和当前hash值指定下标的key一样，先将p赋值给e
e = p;
else if (p instanceof TreeNode)
//如果此时桶中数据类型为 treeNode，使用红黑树进行插入，调用putTreeVal方法
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果此时桶中数据类型为链表，遍历
// 进行循环。注意e = p.next这个一直将下一节点赋值给e，直到尾部，注意开头是++binCount
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//如果链表中没有最新插入的节点，将新放入的数据放到链表的末尾
p.next = newNode(hash, key, value, null);
//判断当前链表长度是否超过8.如果超过8 就会调用treeifyBin方法
//treeifyBin方法的底层还会继续判断 数组的长度是否大于等于64，如果同时满足这两个条件 就会把这个链表转成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果哈希值一样，就会调用equals方法比较内部的属性值是否相同。若都相同 跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果e为null 表示当前不需要覆盖任何元素
//如果e不为null，表明当前的键是一样的，值会被覆盖
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果此时hashMap size大于阈值，则进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict); //与LinkedHashMap有关
//表示当前没有覆盖任何元素，返回null
return null;
}
源码详解
1.看源码之前需要了解的一些内容
Node<K,V>[] table 哈希表结构中数组的名字
DEFAULT_INITIAL_CAPACITY： 数组默认长度16
DEFAULT_LOAD_FACTOR： 默认加载因子0.75
HashMap里面每一个对象包含以下内容：
1.1 链表中的键值对对象
包含：
int hash; //键的哈希值
final K key; //键
V value; //值
Node<K,V> next; //下一个节点的地址值
1.2 红黑树中的键值对对象
包含：
int hash; //键的哈希值
final K key; //键
V value; //值
TreeNode<K,V> parent; //父节点的地址值
TreeNode<K,V> left; //左子节点的地址值
TreeNode<K,V> right; //右子节点的地址值
boolean red; //节点的颜色
2.添加元素
HashMap<String,Integer> hm = new HashMap<>();
hm.put("aaa" , 111);
hm.put("bbb" , 222);
hm.put("ccc" , 333);
hm.put("ddd" , 444);
hm.put("eee" , 555);
添加元素的时候至少考虑三种情况：
2.1 数组位置为null，底层会创建一个键值对对象，直接放到数组当中
2.2 数组位置不为null，键不重复，挂在下面形成链表或者红黑树
2.3 数组位置不为null，键重复，元素覆盖
//参数一：键
//参数二：值
//返回值：被覆盖元素的值，如果没有覆盖，返回null
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);
}
//参数一：键的哈希值
//参数二：键
//参数三：值
//参数四：如果键重复了是否保留
// true，表示老元素的值保留，不会覆盖
// false，表示老元素的值不保留，会进行覆盖
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
//定义一个局部变量，用来记录哈希表中数组的地址值。
Node<K,V>[] tab;
//临时的第三方变量，用来记录键值对对象的地址值
Node<K,V> p;
//表示当前数组的长度
int n;
//表示索引
int i;
//把哈希表中数组的地址值，赋值给局部变量tab
tab = table;
if (tab == null || (n = tab.length) == 0){
//1.如果当前是第一次添加数据，底层会创建一个默认长度为16，加载因子为0.75的数组
//2.如果不是第一次添加数据，会看数组中的元素是否达到了扩容的条件
//如果没有达到扩容条件，底层不会做任何操作
//如果达到了扩容条件，底层会把数组扩容为原先的两倍，并把数据全部转移到新的哈希表中
tab = resize();
//表示把当前数组的长度赋值给n
n = tab.length;
}
//拿着数组的长度跟键的哈希值进行计算，计算出当前键值对对象，在数组中应存入的位置
i = (n - 1) & hash;//index
//获取数组中对应元素的数据
p = tab[i];
if (p == null){
//底层会创建一个键值对对象，直接放到数组当中
tab[i] = newNode(hash, key, value, null);
}else {
Node<K,V> e;
K k;
//等号的左边：数组中键值对的哈希值
//等号的右边：当前要添加键值对的哈希值
//如果键不一样，此时返回false
//如果键一样，返回true
boolean b1 = p.hash == hash;
if (b1 && ((k = p.key) == key || (key != null && key.equals(k)))){
e = p;
} else if (p instanceof TreeNode){
//判断数组中获取出来的键值对是不是红黑树中的节点
//如果是，则调用方法putTreeVal，把当前的节点按照红黑树的规则添加到树当中。
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);
//判断当前链表长度是否超过8，如果超过8，就会调用方法treeifyBin
//treeifyBin方法的底层还会继续判断
//判断数组的长度是否大于等于64
//如果同时满足这两个条件，就会把这个链表转成红黑树
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
//e： 0x0044 ddd 444
//要添加的元素： 0x0055 ddd 555
//如果哈希值一样，就会调用equals方法比较内部的属性值是否相同
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))){
break;
}
p = e;
}
}
//如果e为null，表示当前不需要覆盖任何元素
//如果e不为null，表示当前的键是一样的，值会被覆盖
//e:0x0044 ddd 555
//要添加的元素： 0x0055 ddd 555
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null){
//等号的右边：当前要添加的值
//等号的左边：0x0044的值
e.value = value;
}
afterNodeAccess(e);
return oldValue;
}
}
//threshold：记录的就是数组的长度 * 0.75，哈希表的扩容时机 16 * 0.75 = 12
if (++size > threshold){
resize();
}
//表示当前没有覆盖任何元素，返回null
return null;
}
从代码来看，put方法分为三种情况
-
table尚未初始化，对数据进行初始化
-
table已经初始化，且通过hash算法找到下标所在的位置数据为空,直接将数据存放到指定位置
-
table已经初始化，且通过hash算法找到下标所在的位置数据不为空，发生hash冲突（碰撞），发生碰撞后，会执行以下操作：
- 判断插入的key如果等于当前位置的key的话，将 e 指向该键值对
- 如果此时桶中数据类型为 treeNode，使用红黑树进行插入
- 如果是链表，则进行循环判断， 如果链表中包含该节点，跳出循环，如果链表中不包含该节点，则把该节点插入到链表末尾，同时，如果链表长度超过树化阈值（TREEIFY_THRESHOLD）且table容量超过最小树化容量（MIN_TREEIFY_CAPACITY），则进行链表转红黑树（由于table容量越小，越容易发生hash冲突，因此在table容量<MIN_TREEIFY_CAPACITY 的时候，如果链表长度>TREEIFY_THRESHOLD,会优先选择扩容，否则会进行链表转红黑树操作）
添加元素的时候至少考虑三种情况：
- 数组位置为null，底层会创建一个键值对对象，直接放到数组当中
- 数组位置不为null，键不重复，挂在下面形成链表或者红黑树
- 数组位置不为null，键重复，元素覆盖（同一个key，值不同）
首先分析table尚未初始化的情况：
n = (tab = resize()).length; //table尚未初始化的时候，会调用resize()方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//1.table已经初始化，且容量 > 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
}
//2.阈值大于0 threshold 使用 threshold 变量暂时保存 initialCapacity 参数的值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//3.threshold 和 table 皆未初始化情况，此处即为首次进行初始化
//也就在此处解释了构造方法中没有对threshold 和 初始容量进行赋值的问题
else { // zero initial threshold signifies using defaults
//如果阈值为零，表示使用默认的初始化值。这种情况在调用无参构造的时候会出现，此时使用默认的容量和阈值
newCap = DEFAULT_INITIAL_CAPACITY;
//此处阈值即为 threshold=initialCapacity*loadFactor
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// newThr 为 0 时，按阈值计算公式进行计算，容量*负载因子
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;
//如果之前的数组桶里面已经存在数据，由于table容量发生变化，hash值也会发生变化，需要重新计算下标
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果指定下标下有数据
if ((e = oldTab[j]) != null) {
//1）将指定下标数据置空
oldTab[j] = null;
//2）指定下标只有一个数据
if (e.next == null)
//直接将数据存放到新计算的hash值下标下
newTab[e.hash & (newCap - 1)] = e;
//3）如果是TreeNode数据结构
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//4）对于链表，数据结构
else { // preserve order
//如果是链表，重新计算hash值，根据新的下标重新分组
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;
}
resize方法逻辑比较复杂，需要静下心来一步步的分析，但是总的下来，分为以下几步：
- 首先先判断当前table是否进行过初始化，如果没有进行过初始化，此处就解决了调用无参构造方法时候，threshold和initialCapacity 未初始化的问题，如果已经初始化过了，则进行扩容，容量为原来的二倍
- 扩容后创建新的table，并对所有的数据进行遍历
- 如果新计算的位置数据为空，则直接插入
- 如果新计算的位置为链表，则通过hash算法重新计算下标，对链表进行分组
- 如果是红黑树，则需要进行拆分操作
2.2.3.2 get方法，查找
put方法分析完成之后，剩下的就很简单了，先看一下源码：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
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) {
//1）根据hash算法找到对应位置的第一个数据，如果是指定的key，则直接返回。
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);
//如果该节点是链表，则遍历查找到数据。当链表后续为null 退出循环
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
get方法相对于put来说，逻辑简单很多：
- 根据hash值查找到指定位置的数据
- 校验指定位置第一个节点的数据是key是否为传入的key，如果是直接返回第一个节点，否则继续查找第二个节点
- 如果数据是TreeNode（红黑树结构），直接通过红黑树查找节点数据并返回
- 如果是链表结构，循环查找所有节点，返回数据
- 如果没有找到符合要求的节点，返回null
在这个方法里面，需要注意的有两个地方：hash（key）和hash的取模运算 (n - 1) & hash。
hash(key)源码
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这段代码叫做扰动函数，也是hashMap中的hash运算，主要分为下面几步：
- key.hashCode()，获取key的hashCode值，如果不进行重写的话返回的是根据内存地址得到的一个int值
- key.hashCode() 获取到的hashcode无符号右移16位并和原hashCode进行^ ，这样做的目的是为了让高位与低进行混合，让两者都参与运算，以便让hash值分布更加均匀
取模运算 (n - 1) & hash
在hashMap的代码中，在很多地方都会看到类似的代码：
first = tab[(n - 1) & hash])
hash算法中，为了使元素分布的更加均匀，很多都会使用取模运算，在hashMap中并没有使用hash%n这样进行取模运算，而是使用(n - 1) & hash进行代替，原因是在计算机中，&的效率要远高于%；需要注意的是，只有容量为2的n次幂的时候，(n - 1) & hash 才能等效hash%n，这也是hashMap 初始化初始容量时，无论传入任何值，都会通过tableSizeFor(int cap) 方法转化成2的n次幂的原因，这种巧妙的设计真的很令人惊叹； 至于为什么只有2的n次幂才能这样进行取模运算，这里就不再详细叙述了，有兴趣的可以看一下一位大佬写的文章：由HashMap哈希算法引出的求余%和与运算&转换问题
2.2.3.3 remove方法，删除
了解完get方法之后，我们再最后了解一下remove方法：
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//根据key和key的hash值，查找到对应的元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//如果查找到了元素node，移除即可
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果是TreeNode，通过树进行移除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果是第一个节点，移除第一个节点，将index下标的位置指向第二个节点
else if (node == p)
tab[index] = node.next;
else
//如果不是链表的第一个节点，则移除该节点
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
从源码可以看出来，通过key找到需要移除的元素操作过程和get方法几乎一致，最后在查找到key对应的节点之后，根据节点的位置和类型，进行相应的移除操作就完成了，过程非常简单。
2.3 说一下HashMap的实现原理
HashMap的数据结构： 底层使用hash表数据结构，即数组和链表或红黑树。jdk1.7使用的是 数组+链表，jdk1.8 当链表长度大于阈值（默认为8）并且数组长度达到64时 会转换为红黑树
初始容量：HashMap 的初始容量是 0，这是一种懒加载机制，直到第一次 put 操作才会初始化数组大小，默认大小是 16。
扩容逻辑：
HashMap 使用的是拉链法来解决散列冲突，扩容并不是必须的，但是不扩容的话会造成拉链的长度越来越长，导致散列表的时间复杂度会倾向于 O(n) 而不是 O(1)。
HashMap 扩容的触发时机出现在元素个数超过阈值（容量 * loadFactor）的时候时，会将集合的一维数组扩大一倍，然后重新计算每个元素的位置。
- 当我们往HashMap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标
- 存储时，如果出现hash值相同的key，此时有两种情况。
- 如果key相同，则覆盖原始值；
- 如果key不同（出现冲突），则将当前的key-value放入链表或红黑树中
- 获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。
注意：链表的长度大于8 且 数组长度大于64转换为红黑树
面试官追问：HashMap的jdk1.7和jdk1.8有什么区别
2.4 HashMap的jdk1.7和jdk1.8有什么区别
- JDK1.8之前采用的是拉链法。拉链法：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。
- jdk1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值（默认为8） 时并且数组长度达到64时，将链表转化为红黑树，以减少搜索时间。扩容 resize( ) 时，红黑树拆分成的树的结点数小于等于临界值6个，则退化成链表
2.5 HashMap的put方法的具体流程
-
判断键值对数组table是否为空或为null，否则执行resize()进行扩容（初始化）
-
根据键值key计算hash值得到数组索引
-
判断table[i]==null，条件成立，直接新建节点添加
-
如果table[i]==null ，不成立
- 判断table[i]的首个元素是否和key一样，如果相同直接覆盖value
- 判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对
- 遍历table[i]，链表的尾部插入数据，然后判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，遍历过程中若发现key已经存在直接覆盖value
-
插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold（数组长度*0.75），如果超过，进行扩容。
2.6 讲一讲HashMap的扩容机制
- 在添加元素或初始化的时候需要调用resize方法进行扩容，第一次添加数据初始化数组长度为16，以后每次扩容都是达到了扩容阈值（数组长度 * 0.75）
- 每次扩容的时候，都是扩容之前容量的2倍；
- 扩容之后，会新创建一个数组，需要把老数组中的数据挪动到新的数组中
- 没有hash冲突的节点，则直接使用 e.hash & (newCap - 1) 计算新数组的索引位置
- 如果是红黑树，走红黑树的添加
- 如果是链表，则需要遍历链表，可能需要拆分链表，判断(e.hash & oldCap)是否为0，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上
2.7 hashMap的寻址算法
- 扰动算法：hash值更加均匀，减少hash冲突。主要分为两步
- key.hashCode()，获取key的hashCode值，如果不进行重写的话返回的是根据内存地址得到的一个int值
- key.hashCode() 获取到的hashcode无符号右移16位并和原hashCode进行^ ，这样做的目的是为了让高位与低进行混合，让两者都参与运算，以便让hash值分布更加均匀
- (n - 1) & hash：得到数组中的索引，代替取模，性能更好。数组长度必须是2的n次幂
2.8 为什么我们需要hash()函数 (n-1)&hash，而不是直接用key的hashcode直接计算下标
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
//...
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//...
}
让高位也参与运算，使得分布更加散列，最终达到降低哈希冲突的目的。
详解如下：
假设扩容前的长度为16，key的hash值为xxxx 1011，则扩容前元素的下标计算过程为：
int index =(n - 1) & hash;
= (16 - 1) & xxxx 1011
= 15 & xxxx 1011
= 1111 & xxxx 1011
= 1011
= 11
因为与(&)计算原理为必须对位的两个值都是1才为1，所以这里实际参与计算的只有hash值的低4位；
由于HashMap的容量为2的次方，所以(容量-1)可以转化为N个相连的数位1；在发生扩容后，容量增长为原来的两倍即32，此时参与重新计算下标的值为 (n-1)=31，转化为二进制为 1 1111；
int index =(n - 1) & hash;
= (32 - 1) & xxxx 1011
= 31 & xxxx 1011
= 1 1111 & xxxx 1011
我们看一下两次运算结构的差别
可以看到扩容前hash值实际参与运算的数位为4，扩容后实际参与运算的数位为5；由于扩容前后hash值是不变的，所以运算结果的后4位也不会发生改变；
当扩容后的最高位，也就是第5位对应的x值为0时，最后的运算结果和原来一样，即此节点在新表中的下标和原来一样，归入不需要迁移的链表中；
当第5位对应的x值为1时，最后运算结果的后4为和原来一样，只是第五位变成了1，下标值发生了改变，归入需要迁移的链表中。可以理解为
11011 = 1011 + 1 0000 ;
新下标 = 旧下标 + 旧容量;
总结
- 当x=0时（也就是源码中 (e.hash & oldCap) == 0），此节点在新表中的位置不需要移动。
- 当x=1时（也就是源码中 (e.hash & oldCap) == 1）,此节点在新表中的位置发生了移动，移动的方式为：新下标 = 旧下标 + 旧容量。
通过计算可以发现，当容量为16时，通过对两个最高位不同、最低位相同的key求下标时，最后的结果是相等的；假如这样的key很多，则可能导致大量元素都被放入同一个桶中，造成hash冲突的可能性非常高。
为了避免这种情况出现，在进行下标计算前，我们需要通过hash函数对key的hashCode进行扰动运算，让高位也参与运算，使得分布更加散列，最终达到降低哈希冲突的目的。
2.9 为何HashMap的数组长度一定是 2^n 次幂？
这是为了尽量将集合元素均摊到数组的不同位置上。
- 计算索引时效率更高：如果是 2 的 n 次幂可以使用位与运算代替取模【HashMap 在确定元素对应的数组下标时，是采用了 hashCode 对数组长度取余的运算，它其实等价于 hashCode 对数组长度 - 1 的与运算（h % length 等价于 h & (lenght -1)，与运算效率更高，偶数才成立）】
- 而 2^n 次幂对应的 length - 1 恰好全是 1（1000-1 = 111），这样就把影响下标的因素归结于 hashCode 本身，因而能够实现尽可能均摊。
- 扩容时重新计算索引效率更高： hash & oldCap == 0 的元素留在原来位置 ，否则新位置 = 旧位置 + oldCap
2.10 hashmap在1.7情况下的多线程死循环问题
jdk7的的数据结构是：数组+链表
在数组进行扩容的时候，因为链表是头插法，在进行数据迁移的过程中，有可能导致死循环【下面代码是HashMap的扩容操作，重新定位每个桶的下标，并采用头插法将元素迁移到新数组中。头插法会将链表的顺序翻转，这也是形成死循环的关键点】
参考回答：
在jdk1.7的hashmap中在数组进行扩容的时候，因为链表是头插法，在进行数据迁移的过程中，有可能导致死循环。
比如说，现在有两个线程
线程一：读取到当前的hashmap数据，数据中一个链表，在准备扩容时，线程二介入
线程二：也读取hashmap，直接进行扩容。因为是头插法，链表的顺序会进行颠倒过来。比如原来的顺序是AB，扩容后的顺序是BA，线程二执行结束。
线程一：继续执行的时候就会出现死循环的问题。
线程一先将A移入新的链表，再将B插入到链头，由于另外一个线程的原因，B的next指向了A，所以B->A->B,形成循环。当然，JDK 8 将扩容算法做了调整，不再将元素加入链表头（而是保持与扩容前一样的顺序），尾插法，就避免了jdk7中死循环的问题。
2.11 为什么经常使用String作为HashMap的Key
1、不可变类 String 可以避免修改后无法定位键值对： 假设 String 是可变类，当我们在 HashMap 中构建起一个以 String 为 Key 的键值对时，此时对 String 进行修改，那么通过修改后的 String 是无法匹配到刚才构建过的键值对的，因为修改后的 hashCode 可能是变化的。而不可变类可以规避这个问题。
2、String 能够满足 Java 对于 hashCode() 和 equals() 的通用约定： 既两个对象 equals() 相同，则 hashCode() 相同，如果 hashCode() 相同，则 equals() 不一定相同。这个约定是为了避免两个 equals() 相同的 Key 在 HashMap 中存储两个独立的键值对，引起矛盾。
2.12 HashMap与Hashtable的区别
Hashtable和HashMap都是 基于hash表实现的K-V结构的集合，Hashtable是jdk1.0引入的一个线程安全的集合类，内部使用数组+链表的形式来实现
从功能特性的角度来说
1、Hashtable是线程安全的（HashTable 对每个方法都增加了 synchronized），而HashMap不是
2、HashMap的性能要比Hashtable更好，因为Hashtable采用了全局同步锁来保证安全性，对性能影响较大
从内部实现的角度来说
1）Hashtable使用数组加链表，HashMap采用了数组+链表+红黑树
2）HashMap初始容量是16，Hashtable初始容量是11
3）HashMap可以使用null作为key；而Hashtable不允许 null 作为 Key，会抛出NullPointerException异常
他们两个的key的散列算法不同：Hashtable直接是使用key的hashcode对数组长度取模；而HashMap对key的hashcode做了二次散列，从而避免key的分布不均匀影响到查询性能
参考黑马程序员相关视频和笔记
211
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
