JDK1.7HashMap
JDK1.7的HashMap很多地方都跟1.8HashMap相似，想了解更多的HashMap知识可以看看这篇关于1.8的文章
概述
在介绍HashMap的数据结构之前，我们先来看看我们之前都学习过的结构，回忆回忆它的各自的特点是什么。
数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)
线性链表：对于链表的新增，删除等操作（在找到指定操作位置后），仅需处理结点间的引用即可，时间复杂度为O(1)，而查找操作需要遍历链表逐一进行比对，复杂度为O(n)
二叉树：对一棵相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度均为O(logn)。
哈希表：相比上述几种数据结构，在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下（），仅需一次定位即可完成，时间复杂度为O(1)，值得插一嘴的是，我们要介绍的主角HashMap采用的就是一个由数组+链表组成的哈希表，接下来我们就来看看哈希表是如何实现达到常数阶O(1)如此高性能的。
有计算机基础的伙伴应该都知道，抽象逻辑数据结构的物理存储只有两种结构：顺序存储结构和链式存储结构（像栈，队列，树，图等是从逻辑结构去抽象的，映射到内存中，但本质上在计算机中实际存储的也这两种物理组织形式），而在上面我们提到过，在数组中根据下标查找某个元素，一次定位就可以找到元素，哈希表采用了数组的这种特性，而且哈希表的主干就是数组。
**比如我们要新增或查找某个元素，我们可以把跟当前元素相关的关键字 通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成查找操作。**这个函数就叫做哈希函数。 这个函数的设计好坏会直接影响到哈希表的优劣。
哈希冲突
虽然哈希表能够一次定位找到查找的元素是否存在，但是也有其他的问题，比如说如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。
前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算时的简单性以及散列的地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。
那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap即是采用了链地址法，也就是数组+链表的方式。
基础
HashMap的主干是一个Entry数组。Entry是HashMap的基本组成单元，每一个Entry包含一个key-value键值对。（其实所谓Map其实就是保存了两个对象之间的映射关系的一种[集合]
简单来说，HashMap由数组+链表组成的，数组是HashMap的主体，链表则是主要为了解决哈希冲突而存在的，如果定位到的数组位置不含链表（当前entry的next指向null）,那么查找，添加等操作很快，仅需一次寻址即可；如果定位到的数组包含链表，对于添加操作，其时间复杂度为O(n)，首先遍历链表，存在即覆盖，否则新增；对于查找操作来讲，仍需遍历链表，然后通过key对象的equals方法逐一比对查找。所以，性能考虑，HashMap中的链表出现越少，性能才会越好。
JDK1.7中的HashMap调用put方法进行添加元素时候使用的是头插法，table数组存放的是节点的引用，真正的节点对象存放在堆中；首次添加元素的时候，会将元素的引用存放在table数组中，该引用指向堆中的对象；如下图所示：
再次往里面添加元素的时候，只需要将节点指向堆中的对象，然后将table中数组的引用换成新添加对象的引用，即可完成头插法添加元素。
常见面试题
快速失败机制？
快速失败的机制跟这两个modCount和expectedModCount属性有关，modCount用于记录HashMap元素修改的次数；expectedModCount会在迭代器初始化时被赋值为modCount。
下面的程序之所以会报错是因为迭代器的remove方法不仅修改了modCount，还同步更新了expectedModCount，而**集合的remove方法只修改了modCount，不会同步expectedModCount，所以后者在调用iterator.next()时会快速失败，而前者不会。（前提是在迭代器遍历集合过程中新增、修改或删除了元素）**
public static void main(String[] args) {
HashMap<String,String> hashMap=new HashMap<>();
hashMap.put("1","1");
hashMap.put("2","2");
for(String key : hashMap.keySet()){
if ( key.equals("1"))hashMap.remove(key);
}
}
PUT方法大致流程
找到table下标的过程如下，
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L64Wa130-1652188661513)(img/1652182514163.png)]
PUT方法流程
1、通过 HashMap 自己提供的hash 算法算出当前 key 的hash 值
2、通过计算出的hash 值去调用 indexFor 方法计算当前对象应该存储在数组的几号位置
3、判断size 是否已经达到了当前扩容阈值，如果没有，则继续；如果已经达到阈值，则先进行数组扩容，将数组长度扩容为原来的2倍。
请注意：size 是当前容器中已有 Entry 的数量，不是数组长度。
4、将当前对应的 hash，key，value封装成一个 Entry，去数组中查找当前位置有没有元素，
? 4.1、该位置如果没有Entry对象，则将封装好的Entry放在这个位置上；
? 4.2、如果此位置上已经存在链表，那么遍历链表，
? 4.2.1、如果链表上某个节点的 key 与当前key 进行 equals 比较后结果为 true，则把原来节点上的value 返回，将当前新的 value替换掉原来的value。
? 4.2.2、如果遍历完链表，没有找到key 与当前 key equals为 true的，就把刚才封装的新的 Entry中next 指向当前链表的始节点，也就是说当前节点现在在链表的第一个位置，简单来说是头插法，即先来的往后退。
GET方法大致流程
1、当调用get方法时首先判断输入的key是否为空,如果为空,从hashmap数组下标为0的位置获取值返回
然后会调用hash函数，这个hash函数会将key对应的hashCode值返回，将返回的hashcode与entry数组长度-1进行逻辑与运算得到一个index值，用这个index值来确定数据存储在entry数组当中的位置。
2、通过循环来遍历索引位置对应的链表，初始值为数据存储在entry数组当中的位置，循环条件为entry对象不为null，改变循环条件为entry对象的下一个节点。
3、如果hash函数得到的hash值与entry对象中key的hash值相等并且entry对象当中的key值与get方法传进来的key值equals相同则返回entry对象的value值，否则返回null。
扩容的大致原理
源码概述
重要属性及常量
属性
//HashMap的主干数组，可以看到就是一个Entry数组，初始值为空数组{}，主干数组的长度一定是2的次幂。
//至于为什么这么做，后面会有详细分析。
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
/**实际存储的key-value键值对的个数*/
transient int size;
/**扩容阈值，当table == {}时，该值为初始容量（初始容量默认为16）；当table被填充了，也就是为table分配内存空间后，
threshold一般为 capacity*loadFactory。HashMap在进行扩容时需要参考threshold，后面会详细谈到*/
int threshold;
/**负载因子，代表了table的填充度有多少，默认是0.75
加载因子存在的原因，还是因为减缓哈希冲突，如果初始桶为16，等到满16个元素才扩容，某些桶里可能就有不止一个元素了。
所以加载因子默认为0.75，也就是说大小为16的HashMap，到了第13个元素，就会扩容成32。
*/
final float loadFactor;
/**HashMap被改变的次数，由于HashMap非线程安全，在对HashMap进行迭代时，
如果期间其他线程的参与导致HashMap的结构发生变化了（比如put，remove等操作），
需要抛出异常ConcurrentModificationException，达到快速失败的效果*/
transient int modCount;
常量
/**
数组的默认初始容量16-必须是2次幂。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
最大容量：如果任何一个具有参数的构造函数隐式指定了（is implicitly specified by）一个更大的值，则使用的该最大容量。必须是2次幂<= 1<<30。
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
默认装载因子，在构造函数中未指定加载因子时使用。
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
一个空表实例，以便在表没有膨胀时共享。
*/
static final Entry<?,?>[] EMPTY_TABLE = {};
内部结构
Entry是HashMap中的一个静态内部类。
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;// map中key值，可以为null。
V value;// map中的value值，可以为null。
//存储指向下一个Entry的引用，单链表结构，防止key值不同，hash值相同,解决哈希冲突
Entry<K,V> next;。
int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算
/**
* Creates new entry.
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
常见的构造方法
HashMap有4个构造器，其他构造器如果用户没有传入initialCapacity 和loadFactor这两个参数，会使用默认值
initialCapacity默认为16，loadFactory默认为0.75
无参构造方法
//调用的是二参构造方法
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
一参构造方法
//调用的是二参构造方法
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
二参构造方法
从这段代码我们可以看出，在常规构造器中，并没有一开始就为数组table分配内存空间（有一个入参为指定Map的构造器例外），而是在执行put操作的时候才真正构建table数组
public HashMap(int initialCapacity, float loadFactor) {
//此处对传入的初始容量进行校验，最大不能超过MAXIMUM_CAPACITY = 1<<30(230)
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
threshold = initialCapacity;
init();//init方法在HashMap中没有实际实现，不过在其子类如 linkedHashMap中就会有对应实现
}
PUT方法源码分析
public V put(K key, V value) {
//判断哈希表内容是否为空，如果table数组为空数组{}，进行数组填充（为table分配实际内存空间），入参为threshold
if (table == EMPTY_TABLE) {
//首次添加元素肯定为空，进行初始化
inflateTable(threshold);
}
//若果添加的元素对应的key是null，存储位置为table[0]或table[0]的冲突链上
if (key == null)
//会进行特殊处理，说明我们的HashMap是支持key为null的，将其放在table数组的第0个位置，哈希值是0；也有覆盖的情况
return putForNullKey(value);
//根据元素的key计算对应的hash值
int hash = hash(key);
//根据计算出来的hash值以及table数组的长度去计算元素存放的桶下标
int i = indexFor(hash, table.length);
/*
为什么这里会有个循环呢？ JDK1.7的put方法在存入两个key相同的元素时，会进行覆盖操作，然后返回覆盖之前的key对应的value值，这里的循环就是用来判断该桶下标对应的链表中是否有跟新添加元素相同的key。
因为并不是每次遍历都会到链表尾部，所以不会在这个循环中将新添加的元素进行插入
*/
//得到table数组下标后进行相应循环，刚开始循环时table[i]表示链表的头节点
//如果该对应数据已存在，执行覆盖操作。用新value替换旧value，并返回旧value
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//集合结构修改次数自增，保证并发访问时，若HashMap内部结构发生变化，快速响应失败
modCount++;
//将这几个参数进行封装成Entry对象进行元素添加
addEntry(hash, key, value, i);
return null;
}
inflateTable方法
inflateTable这个方法用于为主干数组table在内存中分配存储空间，通过roundUpToPowerOf2(toSize)可以确保capacity为大于或等于toSize的最接近toSize的二次幂，比如toSize=13,则capacity=16;to_size=16,capacity=16;to_size=17,capacity=32.
private void inflateTable(int toSize) {
// 将容量变化为2的次方数，比如传入的容量值是17，则返回一个32（2的五次方）
int capacity = roundUpToPowerOf2(toSize);//保证capacity一定是2的次幂
//计算扩容阈值
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
//创建一个新的table数组
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
roundUpToPowerOf2
roundUpToPowerOf2中的这段处理使得数组长度一定为2的次幂，Integer.highestOneBit是用来获取最左边的bit（其他bit位为0）所代表的数值.
/*
将容量变化为2的次方数，比如传入的容量值是17，则返回一个32（2的五次方）
*/
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
//这个number-1是保证若果number是16的话，最终返回的值也是16
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
若果是我们去实现这个方法的话，实现思路的关键是如何去判断一个数是否是2的次方数：
1----- 0000 0001
2----- 0000 0010
4----- 0000 0100
8----- 0000 1000
16---- 0001 0000
这里有一个规律，某个数字转化成二进制的话，该二进制串中只有一个位置是1。
所以我们实现的关键就是将该数字转化成二进制数，然后判断该二进制数是否只有一个位置是1，其他位置全是0。这个先到这。
highestOneBit方法的作用是找到小于等于输入参数i的2的次方数，那这里是怎么利用它来获得我们想要的大于等于我们输入的容量的最小2的次方数的？我们可以将我们输入的容量进行左移一位，左移相当于乘2，即将容量变大一倍再传入该highestOneBit方法，最终就能得到我们想要的大于等于我们传入的容量的最小2的次方数。
比如传入的容量是17 ，先左移变成34 ，再调用highestOneBit方法变成32。
highestOneBit方法
/*
该highestOneBit方法的作用是找到小于等于输入参数i的2的次方数
*/
public static int highestOneBit(int i) {
// 进行多次的操作是因为int是32位整数的
i |= (i >> 1);
i |= (i >> 2);
i |= (i >> 4);
i |= (i >> 8);
i |= (i >> 16);
return i - (i >>> 1);
}
该方法的推演过程：假如传入highestOneBit方法的参数 i = 17； 这个 >> 符号表示右移 （ / ） ， 这个| 表示或运算（有1为1）；
先看第一行代码： i |= (i >> 1); //假设 i =17 ，
17 0001 0001 (17对应的二进制)
i >> 1 0000 1000 (将17右移一位)
i |= (i >> 1) 0001 1001 (将右移后跟原来的i 进行或运算)
第二行代码： i |= (i >> 2); （将上面计算的结果进行操作，同理）
此时的i 0001 1001
i >> 2 0000 0110 （右移两位）
i |= (i >> 2); 0001 1110
剩下的分析同理，
>> 8 0000 0000
0001 1111 (后面该结果不会变化)
>> 16 0001 1111 （也就是说此时i对应的二进制数是这个）
然后执行： return i - (i >>> 1);
该句代码分析：i >>> 1 先将i再进行右移一位 ，然后用i 减去右移的结果，最后返回
为什么代码这样设计？可以看出，右移一位再进行或运算之后的效果是最高位的1的后一位也变为1；
001* **** （*表示0或1）
>>1 0001 ****
| 0011 **** (得到第二个1)
接下来再右移两位后再进行或运算之后的效果是最高位的1数起的第二个1的后两个位也变为1；
001* **** （*表示0或1）
>>1 0001 ****
| 0011 **** (得到第二个1)
>>2 0000 11**
| 0011 11**
也就是说每次进行这样的操作时都会将最高位的***变成1（右移几位就变几个）；一步一步将后面的位置变为1；
https://www.bilibili.com/video/BV1x741117jq?t=5077.2
1小时24分
所以最后用后来的 i 减去 i 右移一位，这个结果就是我们要的给定的任意数字，返回比其小的第一个2的次方数。
这里要把容量变成2的次方数这么复杂，那为什么硬是要将其变成2的次方数呢？这样做的意义是什么？这里先留个悬念。
hash方法
//这个k是添加的元素对应的key
final int hash(Object k) {
//默认的hashSeed值为0
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
//符号^表示异或操作，相同为0，不同为1
//调用hashCode方法获取其哈希码，但因为h的值在上面赋值为0，0跟哈希码进行异或会改变h的值
h ^= k.hashCode();
//不断进行右移，异或操作
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
//Entry里面存的不是原来k.hashCode()方法返回的值，而是进行一系列操作后的值
}
这里在算哈希码的时候为什么要进行这么多次的右移、异或操作呢？
这是因为在调用indexFor方法计算下标时，该哈希码要跟数组长度 -1 进行与操作，如下面的indexFor方法介绍的所示，因为int是32位的整数，而在进行与操作的时候哈希码只有低16位参与了与运算，而高16完全不起作用；这就导致两个高位不同而低位相同的key算出来的数组下标产生哈希冲突的概率加大；
**所以我们要尽量让高16位也参与运算，减少哈希碰撞的概率；**那如何才能让哈希码的高16位也能参与到运算中来呢？这就是进行扰动，即多次的右移、异或操作的原因，目的就是为了让散列表更加散列、随机；
这里注意一点，因为传入的key可以是任意对象的，我们可以去重写它的hashCode方法，倘若你自己重写的方法没有对哈希码进行多次的扰动的话，得出来的散列表的散列性就会很差，链表的长度会很长，查询的性能就会很差；
indexFor方法
/*
该方法返回值就是元素存放在桶数组的下标
*/
static int indexFor(int h, int length) {
// assert Integer.bitCount(length) == 1 : "length must be a non-zero power of 2";
return h & (length-1);
}
HashMap对该方法返回的桶下标有如下约束
对该下标的要求有两个：
1、该数组的下标不能越界
2、计算出来的下标要均衡
要满足这两个操作的话进行取余是非常合适的，但是该方法并不是用这个方法实现的，这里使用的是&与操作，并不能满足我们的要求.
但是：这里我们假设返回的哈希值对应的二进制是0101 0101，数组长度16；则 h & (length-1); 有如下运算
length-1=16-1=15
h: 0101 0101
15: 0000 1111
&: 0000 0101(与运算，都为1才为1)
那么最终得出来的结果是否符合上面的两个要求？可以看出哈希码跟长度-1进行相与操作，得出来的结果是哈希码的低4位0101，而低四位的范围是0000~1111，正好是0~15，符合不越界的要求。而且由于哈希码的任意性，这0~15个数也是随机分布的；
这里符合第一个要求的关键是这个数组的长度是16，它是一个二的次方数，二的次方数的一个特点就是它对应的二进制串只有一个1，16减去1之后就得到一个高位全是0低位全是1的数15；
这也是为什么我们要求table数组的容量一定是2的次方数的原因；
至于为什么不用取模操作而用与操作，这是因为与操作是是位操作，是计算机中计算比较快的运算，比取模更快；
addEntry方法
通过以下代码能够得知，当发生哈希冲突并且size大于阈值的时候，需要进行数组扩容，扩容时，需要新建一个长度为之前数组2倍的新的数组，然后将当前的Entry数组中的元素全部传输过去，扩容后的新数组长度为之前的2倍，所以扩容相对来说是个耗资源的操作。
/*
扩容阈值threshold=table数组长度 * 负载因子
*/
void addEntry(int hash, K key, V value, int bucketIndex) {
//判断当前集合中的元素个数size是否大于等于扩容阈值，以确定是否需要进行扩容
if ((size >= threshold)
&&
(null != table[bucketIndex]))
{
resize(2 * table.length);
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
resize扩容方法
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
//table数组已经最大了，不再进行扩容
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
//用扩容后的容量值去创建一个新数组
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
initHashSeedAsNeeded
/**
初始化哈希种子，哈希种子的作用是让生成的哈希码更复杂，使散列表更为散列
这个方法是判断是否进行重哈希的关键，这里我们重点关注其什么时候返回true什么时候返回false
*/
final boolean initHashSeedAsNeeded(int capacity) {
//hashSeed哈希种子默认为0
boolean currentAltHashing = hashSeed != 0;
boolean useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
//进行异或操作，当两个不相等的情况下才会返回true
boolean switching = currentAltHashing ^ useAltHashing;
if (switching) {
hashSeed = useAltHashing
? sun.misc.Hashing.randomHashSeed(this)
: 0;
}
return switching;
}
那什么时候进行重哈希呢？
transfer方法
这个方法将老数组中的数据逐个链表地遍历，扔到新的扩容后的数组中，我们的数组索引位置的计算是通过 对key值的hashcode进行hash扰乱运算后，再通过和 length-1进行位运算得到最终数组索引位置。
使用双重循环将旧table数组的节点元素进行迁移到新数组中，注意在转移完成之后，原来链表中的节点顺序是1-2–3-4，会变成4-3-2-1
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {
//执行while的一次过程就一个元素转移到新数组中，等while循环结束，该位置的链表就全转移到新数组中了；
while(null != e) {
Entry<K,V> next = e.next;
//是否进行重哈希，默认false
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//重新计算元素在数组中的下标
int i = indexFor(e.hash, newCapacity);
// 下面两行代码包含头插法过程
e.next = newTable[i];
newTable[i] = e;
//
e = next;
}
}
}
这个方法是如何将元素进行转移的呢？
rehash默认是false，也就是不进行重新计算哈希值，假设现在某个元素的哈希值对应的二进制是 0101 0101 ， 默认数组长度是16；那么使用indexFor方法进行计算数组下标的时候：
容量为16
hash 0101 0101
15 0000 1111
& 0000 0101
同样，我们在扩容的时候仍然是使用indexFor方法进行计算元素在数组对应下标的，这里rehash默认是false，哈希码就不产生变化，变化的只有数组的长度，由16->32
换句话说，同样的哈希值用同样的indexFor方法进行计算，这里是有一个规律的
容量为32
hash 0101 0101
31 0001 1111 (只有第五位产生变化)
& 0001 0101 （相与的结果只有第五位变化）
从这里就可以看出，旧数组中的一个元素转移到新数组中时有两种情况，以上面的例子来说，第五位是0还是1决定了元素在新数组的位置是原来的位置还是新位置；
若果第五位是0的话，那么元素在新数组中的下标位置不变；
若果是1的话，那么元素在新数组中下标的位置是旧数组长度加上原来下标位置；
当然这个规律的前提条件是元素的哈希码没有进行重哈希；
jdk1.7的循环链表的出现
其中一种情况；
上面分析transfer方法时都是考虑在单线程情况下的，倘若该扩容过程是在多线程情况下，又会变成怎么样呢？在JDK1.7中，会发生链表循环的情况；
假设有两个线程同时对同一个hashmap对象调用put方法
然后两个线程同时判断出来需要进行扩容，所以两个线程都进入到了resize方法中，所以两个线程都会去生成一个数组，然后进入transfer方法
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4Q9xrswM-1652188661514)(img/1651981579988.png)]](https://img-blog.csdnimg.cn/bff0f4b9355849e3ae657c5ef92782f4.png)
也就是说两个线程都会去进行transfer方法的双重循环，将旧数组的元素往新数组中迁移；假设现在两个线程都执行到了这一行代码
对应的指针指向情况如下所示
这个时候，线程1继续往下执行，线程2停留在Entry<K,V> next = e.next;这行代码里，即线程2指向的元素在线程1进行转移的过程中一直都没有发生变化；在线程1执行完转移后，由于头插法的缘故，原本链表的顺序从1-2-3变成了3-2-1；因为线程2在线程1转移的过程中卡住了，在线程1执行完转移后线程2的情况如下所示
这个时候线程2又开始执行了，但是这个时候线程2再将元素迁往线程2创建的新数组的时候（两个线程创建的数组不一样）就会产生循环链表了；恰好线程二又将线程1扩容后的数组进行覆盖成循环链表的数组，这个时候倘若有人采用get方法去获取存在于循环链表中的元素的话，就会不停的进行循环。
而出现循环的关键就是jdk1.7在put方法的时候采用的是头插法；
那为什么要遍历链表将其中的节点一个一个地进行迁移而不是直接将链表的头节点直接迁移到新数组中，这样因为链表的缘故，后面的节点也不需要进行迁移了？
这是因为，扩容的目的是让原来数组中的元素在新数组中的分布更为散列；这样在转移的时候遍历链表，就能够使每个节点分布在数组中的桶位置不同，进而使元素的分布更为均匀，这样在查询的时候效率会更高，而不是只放在一个链表中，使链表的长度不断变长，进而将链表进行拆剪；
而上面的循环链表出现的情况，是假设某个链表在数组进行迁移的时候其元素仍然是迁移到新数组的相同下标又重新形成链表的极为特殊的情况；
createEntry方法
/*
bucketIndex：元素存放的桶下标
*/
void createEntry(int hash, K key, V value, int bucketIndex) {
//下面的两句代码做包含了元素添加的头插法过程
Entry<K,V> e = table[bucketIndex];
//根据计算出来的hash, key, value, e创建出新的Entry对象（就是我们新添加的元素）
table[bucketIndex] = new Entry<>(hash, key, value, e);
//将元素个数自增
size++;
}
GET方法源码
get方法通过key值返回对应value，如果key为null，直接去table[0]处检索。我们再看一下getEntry这个方法
public V get(Object key) {
//如果key为null,则直接去table[0]处去检索即可。
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
getEntry 方法
可以看出，get方法的实现相对简单，key(hashcode)–>hash–>indexFor–>最终索引位置，找到对应位置table[i]，再查看是否有链表，遍历链表，通过key的equals方法比对查找对应的记录。
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
//通过key的hashcode值计算hash值
int hash = (key == null) ? 0 : hash(key);
//indexFor (hash&length-1) 获取最终数组索引，然后遍历链表，通过equals方法比对找出对应记录
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
要注意的是，有人觉得上面在定位到数组位置之后然后遍历链表的时候，e.hash == hash这个判断没必要，仅通过equals判断就可以。其实不然，试想一下，如果传入的key对象重写了equals方法却没有重写hashCode，而恰巧此对象定位到这个数组位置，如果仅仅用equals判断可能是相等的，但其hashCode和当前对象不一致，这种情况，根据Object的hashCode的约定，不能返回当前对象，而应该返回null，后面的例子会做出进一步解释。
重写equals方法需同时重写hashCode方法
public class MyTest {
private static class Person{
int idCard;
String name;
public Person(int idCard, String name) {
this.idCard = idCard;
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()){
return false;
}
Person person = (Person) o;
//两个对象是否等值，通过idCard来确定
return this.idCard == person.idCard;
}
}
public static void main(String []args){
HashMap<Person,String> map = new HashMap<Person, String>();
Person person = new Person(1234,"乔峰");
//put到hashmap中去
map.put(person,"天龙八部");
//get取出，从逻辑上讲应该能输出“天龙八部”
System.out.println("结果:"+map.get(new Person(1234,"萧峰")));
}
}
实际输出结果：null
如果我们已经对HashMap的原理有了一定了解，这个结果就不难理解了。尽管我们在进行get和put操作的时候，使用的key从逻辑上讲是等值的（通过equals比较是相等的），但由于没有重写hashCode方法，所以put操作时，key(hashcode1)–>hash–>indexFor–>最终索引位置 ，而通过key取出value的时候 key(hashcode1)–>hash–>indexFor–>最终索引位置，由于hashcode1不等于hashcode2，导致没有定位到同一个数组位置而返回逻辑上错误的值null（也有可能碰巧定位到一个数组位置，但是也会判断其entry的hash值是否相等，上面get方法中有提到。）
所以，在重写equals的方法的时候，必须注意重写hashCode方法，同时还要保证通过equals判断相等的两个对象，调用hashCode方法要返回同样的整数值。而如果equals判断不相等的两个对象，其hashCode可以相同（只不过会发生哈希冲突，应尽量避免）。
