HashMap

HashMap集合简介

概述

HashMap基于哈希表的Map接⼝口实现，是以key-value存储形式存在，即主要⽤用来存放键值对。它的key、value都可以为null。 HashMap 的实现不是同步的，这意味着它不是线程安全的。此外， HashMap中的映射不是有序的,位置由hashcode经过运算决定。

数据结构

在JDK1.8 之前 HashMap 由 数组+链表 数据结构组成的。
在JDK1.8 之后 HashMap 由 数组+链表 +红⿊树数据结构组成的。

数据结构解析

JDK1.8 之前 HashMap 由数组+链表组成的，数组是 HashMap 的主体，链表则是主要为了了解决哈希冲突(两个对象调用的hashCode⽅法计算的哈希码值一致而导致计算的数组索引值相同)而存在的(“拉链法”解决冲突).JDK1.8 以后在解决哈希冲突时有了较大的变化，当链表长度大于阈值(或者红黑树的边界值，默认为 8)并且当前数组的长度大于64时【同时满足这两个条件】，此时此索引位置上的所有数据改为使用红⿊树存储。

注意：将链表转换成红黑树前会判断，即使阈值大于8，但是数组长度小于64，此时并不会将链表变为 红黑树。⽽是选择进行数组扩容。

为什么要满足以上两个条件？

因为数组比较小的时候要尽量避开红黑树结构，这种情况下变为红黑树结构，反而会降低效率，因为红⿊树需要进行左旋，右旋，变色这些操作来保持平衡 。同时数组⻓度⼩于64时，搜索时间相对要快些。所以综上所述为了提高性能和减少搜索时间，底层在阈值大于8并且数组长度大于64时， 链表才转换为红黑树。具体可以参考 treeifyBin 方法。

当然虽然增了了红黑树作为底层数据结构，结构变得复杂了，但是阈值大于8并且数组长度大于64时，链表转换为红黑树时，效率也变的更⾼效。

小结

1. 存取是无序的。
2. 键和值都都可以是null，但是这些键中仅只能有一个是null。
3. 键位置是唯一的，底层的数据结构控制键的位置。
4. jdk1.8之前数据结构是:链表 + 数组， jdk1.8之后是 : 链表 + 数组 + 红黑树。
5. 阈值(边界值) > 8 并且数组长度大于64，才将链表转换为红黑树，变为红黑树的⽬的是为了高效的查询。

HashMap继承关系

源码

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
  // 省略
}  

1. Cloneable是空接口，表示可以克隆。 代表创建并返回HashMap对象的一个副本。
2. Serializable 序列化接口。属于标记性接口。HashMap对象可以被序列化和反序列化。
3. AbstractMap 父类提供了Map实现接口。以最大限度地减少实现此接口所需的⼯作。

通过上述继承关系我们发现一个很奇怪的现象， 就是HashMap已经继承了AbstractMap而 AbstractMap类实现了Map接⼝口，那为什什么HashMap还要在实现Map接⼝口呢?同样在ArrayList中 LinkedList中都是这种结构。

据 Java集合框架的创始⼈人Josh Bloch描述，这样的写法是⼀个失误。在java集合框架中，类似这样的写法很多，最开始写Java集合框架的时候，他认为这样写，在某些地方可能是有价值的，直到他意识到搞错了。显然的，JDK的维护者，后来不认为这个⼩小的失误值得去修改，所以就这样存在下来了。

HashMap成员变量

序列化版本号

private static final long serialVersionUID = 362498820763181265L;

集合的初始化容量【16】( 必须是二的n次幂 )

// 默认的初始容量是16 -- 1<<4相当于1*2的4次方---1*16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

集合的最大容量【2的30次方】

// 集合最大容量的上限是:2的30次幂
static final int MAXIMUM_CAPACITY = 1 << 30;

默认的负载因子，默认值是0.75

static final float DEFAULT_LOAD_FACTOR = 0.75f;

当链表的值超过8则会转红黑树(JDK1.8新增)

static final int TREEIFY_THRESHOLD = 8;

当链表的值小于6则会从红黑树转回链表

// 当桶(bucket)上的结点数小于这个值时树转链表
static final int UNTREEIFY_THRESHOLD = 6;

转化为红黑树对应的数组长度最小值

// 桶中结构转化为红黑树对应的数组长度最小的值
static final int MIN_TREEIFY_CAPACITY = 64;

当Map⾥面的数量超过这个值时，表中的桶才能进行树形化 ，否则桶内元素太多时会扩容，⽽不是树形化。目的是为了避免进⾏扩容、树形化选择的冲突，这个值不能⼩于 4 * TREEIFY_THRESHOLD (8)

table⽤来初始化(必须是二的n次幂)[重点]

// 存储元素的数组
transient Node<K,V>[] table;

table在JDK1.8中我们了解到HashMap是由数组加链表加红⿊树来组成的结构其中table就是HashMap 中的数组，jdk8之前数组类型是Entry<K,V>类型。从jdk1.8之后是Node<K,V>类型。只是换了个名字， 都实现了一样的接口:Map.Entry<K,V>。负责存储键值对数据的。

⽤来存放缓存

// 存放具体元素的集合
transient Set<Map.Entry<K,V>> entrySet;

java语言的关键字，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。换句话说，用transient关键字标记的成员变量不参与序列化过程。

当一个对象被序列化的时候，transient型变量的值不包括在序列化的表示中，然而非transient型的变量是被包括进去的。

HashMap中存放元素的个数[重点]

// 存放元素的个数，注意这个不等于数组的长度。
transient int size;

size为HashMap中K-V的实时数量，不是数组table的⻓度。

⽤来记录HashMap的修改次数

// 每次扩容和更改map结构的计数器
transient int modCount;

⽤来调整大小下一个容量的值计算方式为(容量*负载因子)

// 临界值 当实际⼤小(容量*负载因⼦)超过临界值时，会进行扩容
int threshold;

哈希表的加载因子[重点]

// 加载因子
final float loadFactor;

loadFactor加载因子，是⽤来衡量 HashMap 中元素满的程度，表示HashMap的疏密程度，可以影响hash操作到同一个数组位置的概率，计算HashMap的实时加载因子的方法为:size/capacity，⽽不是占用桶的数量去除以capacity。capacity 是桶的数量，也就是 table 的⻓度length。size是集合中实际存储元素的个数。

loadFactor太⼤导致查找元素效率低，太小导致数组的利用率低，存放的数据会很分散。loadFactor 的默认值为0.75f是官方给出的⼀个比较好的临界值。

当HashMap⾥面容纳的元素已经达到HashMap数组⻓度的75%时，表示HashMap太挤了，需要扩容，⽽而扩容这个过程涉及到 rehash、复制数据等操作，非常消耗性能。所以开发中尽量减少扩容的次数，可以通过创建HashMap集合对象时指定初始容量来尽量避免。

HashMap的构造方法

构造一个空的 HashMap ，默认初始容量(16)和默认负载因⼦(0.75)

// 构造一个无参数的构造方法
public HashMap() {
  // 将默认的加载因子0.75赋值给loadFactor，并没有创建数组
	this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

构造⼀个具有指定的初始容量和默认负载因子(0.75)HashMap

源码：

// 构造一个指定容量⼤⼩的构造函数
public HashMap(int initialCapacity) {
	this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

// 指定容量⼤小和加载因⼦的构造函数 initialCapacity: 指定的容量 loadFactor:指定的加载因⼦
public HashMap(int initialCapacity, float loadFactor) {
  // 判断初始化容量initialCapacity是否小于0
	if (initialCapacity < 0)
    // 如果⼩于0，则抛出非法的参数异常IllegalArgumentException
		throw new IllegalArgumentException("Illegal initial capacity: " +
				initialCapacity);
  // 判断初始化容量initialCapacity是否⼤于集合的最大容量MAXIMUM_CAPACITY->2的30次幂
	if (initialCapacity > MAXIMUM_CAPACITY)
    // 如果超过MAXIMUM_CAPACITY，会将MAXIMUM_CAPACITY赋值给initialCapacity
		initialCapacity = MAXIMUM_CAPACITY;
  // 判断负载因⼦loadFactor是否小于等于0或者是否是⼀个⾮数值
	if (loadFactor <= 0 || Float.isNaN(loadFactor))
    // 如果满足上述其中之一，则抛出非法的参数异常IllegalArgumentException
		throw new IllegalArgumentException("Illegal load factor: " +
				loadFactor);
  // 将指定的加载因⼦赋值给HashMap成员变量的负载因子loadFactor
	this.loadFactor = loadFactor;
  // tableSizeFor(initialCapacity) 判断指定的初始化容量是否是2的n次幂，如果不是那么会变为⽐指定初始化容量大的最小的2的n次幂。
	this.threshold = tableSizeFor(initialCapacity);
}

案例：

@Test
public void test_hash_map_con_in_lo(){
  // 自定义初始化容量和加载因子
	HashMap<Integer, String> map = new HashMap<>(32, 0.75f);
}

如果这个构造函数的initialCapacity小于0，将会抛出非法异常IllegalArgumentException。
如果loadFactor的值是isNaN，则会抛出非法异常IllegalArgumentException。

构造一个包含另一个Map的构造函数和默认负载因子(0.75)

源码：

public HashMap(Map<? extends K, ? extends V> m) {
	this.loadFactor = DEFAULT_LOAD_FACTOR;
  // 负载因子loadFactor变为默认的负载因子0.75
	putMapEntries(m, false);
}

tableSizeFor方法,返回比指定初始化容量大的最小的2的n次幂

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

符号解析

1. 右移符号。比如给定的值为5【0101】，右移一位为2【0010】。
2. |符号为或运算。比如给定的值11 | 15,11对应的二进制【1011】，15对应的二进制【1111】，11 | 15结果为【1111】15。

源码分析

当在实例化HashMap实例时，如果给定了initialCapacity(假设是5)，由于HashMap的 capacity必须都是2的幂，因此这个方法用于找到大于等于initialCapacity(假设是5)的最小的2的幂。initialCapacity如果就是2的幂，则返回的还是这个数)。

为什么要对cap做减1操作【int n = cap - 1】？

这是为了防⽌，如果cap已经是2的幂， ⼜没有执行这个减1操作，则执行完后面的几条无符号右移操作之后，返回的capacity将是这个cap的2倍。假如cap的值为8，经过上面的计算得到的还是8。

计算举例

以方法tableSizeFor(int cap)举例测试的数 cap = 65
        int n = cap - 1; ===>>>>  n = 65 - 1 = 64
        64 对应二进制 0100 0000 
        n >>> 1       
            右移1位     0100 0000 ===>>>> 0010 0000
            n |= n >>> 1 对应于 0100 0000 | 0010 0000 = 0110 0000 【96】

        n >>> 2       
            右移2位     0110 0000 ===>>>> 0001 1000 
            n |= n >>> 2 对应于 0110 0000 | 0001 1000 = 0111 1000 【120】

        n >>> 4       
            右移4位     0111 1000 ===>>>> 0000 0111
        n |= n >>> 4 对应于 0111 1000 | 0000 0111 = 0111 1111 【127】

        n >>> 8
            右移8位     0111 1111 ===>>>> 0000 0000
            n |= n >>> 8 对应于 0111 1111 | 0000 0000 = 0111 1111 【127】

        n >>> 16
            右移16位     0111 1111 ===>>>> 0000 0000
            n |= n >>> 16 对应于 0111 1111 | 0000 0000 = 0111 1111 【127】

        最后执行  return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; 返回128【128为2的7次幂，加一的原因是凑成整数次幂】 

putMapEntries添加键值对到集合中

// m：给定的集合。evict：最初构造此映射时为false。如果给定的集合为null，将会抛出空指针异常NullPointerException
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
  // 获取给定集合的长度
	int s = m.size();
  // 判断给定的集合长度是否大于0
	if (s > 0) {
    // 判断table是否已经初始化
		if (table == null) { // pre-size
      // 未初始化，s为m的实际元素个数。预先计算一个容量ft。这里为什么加1呢？有啥特殊的含义吗？
			float ft = ((float)s / loadFactor) + 1.0F;
      // 上面计算的容量不小于最大值将这个值赋值给t，否则赋值给最大值
			int t = ((ft < (float)MAXIMUM_CAPACITY) ?
					(int)ft : MAXIMUM_CAPACITY);
      // 判断这个容量是否大于threshold，大于就对这个容量进行格式化，格式为2的幂
			if (t > threshold)
				threshold = tableSizeFor(t);
		}
    // 之前的数组中有元素，判断参数中的数组长度是否大于数组容量
		else if (s > threshold)
      // 扩容
			resize();
    // 遍历给定的集合
		for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
      // 获取给定集合每个键值对的k和v
			K key = e.getKey();
			V value = e.getValue();
      // 将每一个entry的键值对放到数组中
			putVal(hash(key), key, value, false, evict);
		}
	}
}

float ft = ((float)s / loadFactor) + 1.0F这一行代码中为什么要加1.0F？

问题出现的源码
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY);

• s/loadFactor的结果是⼩数，加1.0F与(int)ft相当于是对小数做一个向上取整以尽可能的保证更大容量，更大的容量能够减少resize的调用次数。所以 + 1.0F是为了获取更大的容量。
• 例如:原来集合的元素个数是6个，那么6/0.75是8，是2的n次幂，那么新的数组⼤小就是8了。
• 然后原来数组的数据就会存储到长度是8的新的数组中了，这样会导致在存储元素的时候，容量不够，还得继续扩容，那么性能就会降低了，而如果+1呢，数组长度直接变为16了，这样可以减少数组的扩容次数，从而提高效率。

HashMap的put方法

1、先通过hash值计算出key映射到哪个桶;
2、如果桶上没有发生哈希碰撞冲突，则直接插⼊;
3、如果出现了哈希碰撞冲突，则需要处理冲突。【处理方式一：红黑树】如果该桶使用红黑树处理冲突，则调用红黑树的方法插入数据;【处理方式二：链表】否则采用传统的链式⽅法插入。如果链的长度达到临界值，则把链转变为红黑树;
4、如果桶中存在重复的键，则为该键替换新值value;
5、如果size⼤于阈值threshold，则进行扩容;

方法	描述
public V put(K key, V value)	添加方法
static final int hash(Object key)	求哈希值方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)	实际的添加键值对的方法

public V put(K key, V value)添加方法

源码

public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}

源码分析

• HashMap提供了put方法用于添加元素，从源码中可以看到这个方法调用了putVal方法来真正的添加元素
• 从源码中我们也可以看到putVal方法只是给put方法调用的一个方法，并没有提供给用户使⽤。 所以下面的源码分析中将重点分析putVal⽅法。

在这个map中将指定的key和指定的val做关联，如果这个map之前已经有一个映射对于这个指定的key，那么这个key对应的旧的val将会被替换。

static final int hash(Object key)求哈希值方法

源码

// 获取给定的key对应的哈希值
static final int hash(Object key) {
  // 定义一个变量h,用于接收给定key对应的hashCode
	int h;
  // 返回这个给定key的哈希值
	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

(key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16)解析

• 如果key等于null;可以看到当key等于null的时候也是有哈希值的，返回的是0。
• 如果key不等于null;首先计算出key的hashCode赋值给h,然后与h无符号右移16位后的二进制进行按位异或运算得到最终的hash值。
• HashMap是支持Key和value为空的。
• HashTable是直接⽤Key来获取HashCode所以key为空会抛异常，也可以从源码中看出value为空也抛出空指针异常，并且HashTable的源码注释中有这么一句注释@exception NullPointerException if the key or value is。

&与运算和^异或运算

&与运算
运算规则:相同的二进制数位上，都是1的时候，结果为1，否则为零。
案例：5 & 11 = 1
	5   0101
&	11  1011
………………………………
结果： 0001【运算结果：1】

^异或运算
运算规则:相同的二进制数位上，数字相同，结果为0，不同为1。
案例：5 ^ 11 = 14
	5   0101
^	11  1011
………………………………
结果： 1110【运算结果：14】

(h = key.hashCode()) ^ (h >>> 16)演示

h = key.hashCode(): 1111 1111 1111 1111 1111 1010 1100 1010      这个值代表哈希code值
………………………………………………………………………………………………………………………………………………………………………………………………………………………………
						h	: 1111 1111 1111 1111 1111 1010 1100 1010
					h >>>16 : 0000 0000 0000 0000 1111 1111 1111 1111 
		      h ^ (h >>> 16): 1111 1111 1111 1111 0000 0101 0011 0101
………………………………………………………………………………………………………………………………………………………………………………………………………………………………
(n - 1)&hash计算的是在集合中的插入桶的位置
						 n - 1: 0000 0000 0000 0000 0000 0000 0000 1111【假设的容量为16-1=15】
						  hash:	1111 1111 1111 1111 0000 0101 0011 0101【这个是上面高16位和低16位异或得到的】
			       &与运算的结果:	0000 0000 0000 0000 0000 0000 0000 0101  =>[5]
………………………………………………………………………………………………………………………………………………………………………………………………………………………………
【重点】假如现在扩容，这个容量变为了32，那么上面计算的索引为5，到扩容后的集合的位置可能是5或者是21

(n - 1)&hash计算的是在集合中的插入桶的位置
						 n - 1: 0000 0000 0000 0000 0000 0000 0001 1111【假设的容量为32-1=31】
						  hash:	1111 1111 1111 1111 0000 0101 0011 0101【这个是上面高16位和低16位异或得到的】
			       &与运算的结果:	0000 0000 0000 0000 0000 0000 0001 0101  =>[21]
                假如hash位置为0 :                                  0       =>[5]
………………………………………………………………………………………………………………………………………………………………………………………………………………………………

总结
1、高16 bit 不变，低16 bit 和高16 bit 做了⼀个异或运算(得到的 hashcode 转化为32位二进制，低16 bit和高16 bit做了⼀个异或)。
2、(n-1) & hash => 得到下标。 (n-1): n表示数组长度16，n-1就是15。
3、【取模运算】取余数本质是不断做除法，把剩余的数减去，运算效率要⽐位运算低。

为什么要使用这样的操作？

如果当n，即数组长度很⼩，假设是16的话，那么n-1二进制即为1111 ，这样的值和hashCode()直接做按位与操作，实际上只使用了哈希值的后4位。如果当哈希值的高位变化很大，低位变化很小， 这样就很容易造成哈希冲突了，所以这里把高低位都利利用起来，从⽽解决了这个问题。

final V putVal实际的添加键值对的方法

参数解释

hash : key的hash值
 key : 原始Key
value: 要存放的值
onlyIfAbsent: 如果为true代表不更改现有的值 
evict: 如果为false表示table为创建状态

源码阅读

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
			   boolean evict) {
	HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
  // transient Node<K,V>[] table：表示存储Map集合中元素的数组。
  // (tab = table) == null表示将table赋值给tab,然后判断tab是否等于null，第⼀次添加的时候肯定是 null。
  // (n = tab.length) == 0 表示获取tab的长度赋值给n，然后判断这个n是否等于0。
  // 执行完n = (tab = resize()).length，数组tab每个空间都是null。
	if ((tab = table) == null || (n = tab.length) == 0)
    // 获取初始化后的数组的容量。
    // resize()方法有两个用途。用途1:用来初始化HashMap中存储数据的table数组【resize源码可以看的到】。用途2:给table扩容（即*2）。
		n = (tab = resize()).length;
  // i = (n - 1) & hash 表示计算数组的索引赋值给i，即确定元素存放在哪个桶中。
  // p = tab[i = (n - 1) & hash]表示获取计算出的位置的数据赋值给节点p。
  // (p = tab[i = (n - 1) & hash]) == null 判断节点位置是否等于null。
  // 这个存放元素的位置是线程不安全的，可能会出现一个正在存这个位置，另一个线程取，出现异常安全 currenthashmap使用cas解决 
	if ((p = tab[i = (n - 1) & hash]) == null)
    // 创建一个新的节点存⼊到桶中，索引位置无元素，则创建Node对象，存入数组该位置中
		tab[i] = newNode(hash, key, value, null);
	else {// 如果索引位置已有元素，说明hash冲突，存入单链表或者红黑树中
    // 若已经存在一个节点，它的key与新值的key相等，则用变量e记录这个节点
    // e的作用就是干这个的，下面很长一段代码都是用来判断是否存在这样一个节点
		HashMap.Node<K,V> e; K k;
    // 位置有元素的前提下，判断该位置的key是不是和旧的key值相同
    // 若新值将要插入的位置已经存在的节点，它的key值与新值的key相等，则用变量e记录下它
		// p.hash == hash :p.hash表示原来存在数据的hash值，hash表示后添加数据的hash值，比较两个hash值是否相等
    // (k = p.key) == key :p.key获取原来数据的key赋值给k，key表示后添加数据的key，比较两个key的地址是否相同
    // key != null && key.equals(k):能够执行到这里说明两个key的地址值不相等，判断后添加的key是否等于null，如果不等于再调用equals⽅法判断两个key的内容是否相等。
    if (p.hash == hash &&
				((k = p.key) == key || (key != null && key.equals(k))))
      // e现在为旧值；两个元素哈希值相等，并且key的值也相等，将旧的元素整体对象赋值给e，用e来记录
			e = p;
    // 该位置有元素的前提下，hash值不相等或者key不相等;判断p是否为红黑树结点，若已经存在的节点是一个Tree节点，则使用树的方法将节点加入
    // 用e接收返回值，此处返回值e不为空，表示这棵树上存在与新值的key相同的节点   
		else if (p instanceof TreeNode)
      // 用e接收返回值，此处返回值e不为空，表示这棵树上存在与新值的key相同的节点  
			e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
		else {// 该位置有元素的前提下，hash值不相等或者key不相等;则表示这个位置不是一棵树，而是一个链表
      // 遍历这个链表，binCount代表当前链表的长度，遍历到链表最后节点然后插⼊，采用循环遍历的方式，判断链表中是否有重复的key
			for (int binCount = 0; ; ++binCount) {
        // 若已经到达这个链表的最后一个节点，则用新值创建一个新的节点，并将其插入最后一个节点的末端
        // 判断当前位置的下一个元素是否为空
        // e = p.next 获取p的下一个元素赋值给e
        // (e = p.next) == null 判断p.next是否等于null，等于null，说明p没有下一个元素，那么此时到达了了链表的尾部，还没有找到重复的key,则说明HashMap没有包含该键，将该键值对插⼊链表中
				if ((e = p.next) == null) {
          // 用新值创建一个新的节点，并将其追加到单链表末尾
          // 注意第四个参数next是null，因为当前元素插入到链表末尾了，那么下一个节点肯定是null
          // 这种添加方式也满足链表数据结构的特点，每次向后添加新的元素
					p.next = newNode(hash, key, value, null);
          // 若插入这个节点后，这条链表的的节点数目已经到达了树化的阈值
          // 则将这条链表转换为红黑树
          // 超过树化阈值则进行树化操作 TREEIFY_THRESHOLD = 8，为啥-1 ，原因是binCount从0开始
          // int binCount = 0 :表示for循环的初始化值，从0开始计数。记录着遍历节点的个数。值是0表示第一个节点，1表示第⼆个节点。。。。7表示第八个节点，
					if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
            // 树形化，转换为红黑树【接下来单独开一篇文章介绍】
						treeifyBin(tab, hash);
          // 跳出循环
					break;
				}
        // 若在遍历这条链表的过程中，发现了一个节点，它的key值与新值的key相等，则不插入新节点
        // 且此时由于上面的操作，e已经指向了这个key的节点，不需要继续遍历了，跳出循环
				if (e.hash == hash &&
						((k = e.key) == key || (key != null && key.equals(k))))
          // 要添加的元素和链表中的存在的元素的key相等了，则跳出for循环。不用再继续比较了，直接执行下面的if语句去替换 if(e != null)
					break;
        // 上面判断的节点的下个节点是否为空，显然能执行到这下个节点不为空，并且key也不相同，
        // 换句话说下个节点下有元素，key不相同，将p节点赋值为当前节点，并且判断它的下个节点。
        // 新添加的元素和当前节点不相等，继续查找下一个节点。⽤于遍历桶中的链表，与前面的e = p.next组合，可以遍历链表。
				p = e;
			}
		}
    // 判断e是否为null，若不为空，表示在原来的节点中，存在一个key值与新值的key重复的节点
    // 在桶中找到key值、hash值与插⼊元素相等的结点
    // 也就是说通过上⾯的操作找到了重复的键，所以这里就是把该键的值变为新的值，并返回旧值 这里完成了put方法的修改功能
		if (e != null) { // existing mapping for key
      // 记录下这个节点原来的value值
			V oldValue = e.value;
      // 若onlyIfAbsent的值为false，或者原来的value是null，则用新值替换原来的值
			if (!onlyIfAbsent || oldValue == null)
				e.value = value;
      // 这是一个回调函数，但是在HashMap中是一个空函数
      // 看源码貌似是留给LinkedHashMap去扩充的
      // 感觉这个应该属于模板方法设计模式
			afterNodeAccess(e);
      // 返回旧value，如果在这里被返回，则不会执行剩下的代码
      // 也就是说，若执行到剩下的代码，表示并不是执行修改原有值的操作，而是插入了新节点
			return oldValue;
		}
	}
  // 能运行到这里，表示这次进行的是插入操作，而不是修改
  // modCount用来记录Map（仅指插入+删除）被修改的次数
  // 此处modCount+1，因为HashMap被修改了（新插入了一个节点）
	++modCount;
  // Map中元素的数量+1，并判断元素数量是否到达允许的最大值，若到达，则对Map进行扩容
	if (++size > threshold)
    // 扩容【接下来单独开一篇文章介绍】
		resize();
  // 与上面的afterNodeAccess类似，同为留给LinkedHashMap编写的回调函数   
	afterNodeInsertion(evict);
	return null;
}

final HashMap.Node<K,V>[] resize()扩容源码

源码解析

final Node<K,V>[] resize() {
    // 成员变量的table赋值给oldTab，就是将扩容前的table赋值给oldTab
    // 第一次添加元素的时候oldTab = table=null，再次添加的时候oldTab = table为添加之前的table数组
    Node<K,V>[] oldTab = table;
    // 记录Map当前的容量
    // 如果当前数组等于null长度返回0，否则返回当前数组的长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 记录Map允许存储的元素数量，即阈值（容量*负载因子），超过这个阀值要扩容 
    // 首次添加元素的时候初始化容量这个oldThr=threshold=0，再次添加元素的时候会将当前的扩容阀值赋值给oldThr
    int oldThr = threshold;
    // 声明两个变量，用来记录新的容量和阈值
    int newCap, newThr = 0;
    // 若当前容量不为0，表示存储数据的数组已经被初始化过
    if (oldCap > 0) {
        // 判断当前容量是否超过了允许的最大容量
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 若超过最大容量，表示无法再进行扩容
            // 则更新当前的阈值为int的最大值，并返回旧数组
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 将旧容量*2得到新容量，若新容量未超过最大容量值，并且旧容量大于默认初始容量（16），才则将旧阈值*2得到新阈值
        // 在以前的扩容阀值的基础上翻倍，假如以前的数组长度16 扩容阀值为 16*0.75=12
        // 扩容新的容量为之前的容量的2倍newCap = oldCap << 1 左移一位 原来的大小为 16 扩容以后位32  以此类推
        // 新的扩容阀值也为原来的2倍 newThr = oldThr << 1; 左移动1位  原来的扩容阀值为12 现在的阀值为24  以此类推
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            // 将旧阈值*2得到新阈值
            newThr = oldThr << 1; // double threshold
    }
    // 若不满足上面的oldCap > 0，表示数组还未初始化，
    // 若当前阈值不为0，就将数组的新容量记录为当前的阈值；
    // 为什么这里的oldThr在未初始化数组的时候就有值呢？
    // 这是因为HashMap有两个带参构造器，可以指定初始容量，
    // 若你调用了这两个可以指定初始容量的构造器，
    // 这两个构造器就会将阈值记录为第一个大于等于你指定容量，且满足2^n的数（可以看看这两个构造器）
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;
    // 若上面的条件都不满足，表示你是调用默认构造器创建的HashMap，且还没有初始化table数组
    else {               // zero initial threshold signifies using defaults
        // 则将新容量更新为默认初始容量（16）
        // 阈值即为（容量*负载因子）12
        // 初始化容量会走这个
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 经过上面的步骤后，newCap一定有值，但是若运行的是上面的第二个分支时，newThr还是0
    // 所以若当前newThr还是0，则计算出它的值（容量*负载因子）
    if (newThr == 0) {
        // 再次扩容的阀值
        float ft = (float)newCap * loadFactor;
        // 获取新的阀值，小于最大容量就为上面计算的扩容阀值，否则为Integer.MAX_VALUE
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    // 将计算出的新阈值更新到成员变量threshold上
    // 第一次添加的时候初始化threshold = newThr = 12
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    // 创建一个记录新数组用来存HashMap中的元素，容量为新的容量newCap
    // 若数组不是第一次初始化，则这里就是创建了一个两倍大小的新数组
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    // 将新的的数组赋值给成员变量table
    table = newTab;
    // 判断旧数组是否等于空,不等于null开始将原来的数据加入到新数组中
    if (oldTab != null) {
        // 遍历原数组。把每个bucket都移动到新的bucket中，遍历旧的哈希表的每个桶，重新计算桶里元素的新位置
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            // 若原数组的j位置有节点存在，才进一步操作
            if ((e = oldTab[j]) != null) {
                // 清除旧数组对节点的引用,方便垃圾回收
                oldTab[j] = null;
                // 若table数组的j位置只有一个节点，则直接将这个节点放入新数组，位置可能在新的之前的位置也肯能在旧的容量加上旧的位置
                // 使用 & 替代 % 计算出余数，即下标
                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
                    // 创建两个头尾节点，表示两条链表
                    // 因为旧链表上的元素放入新数组中，最多将变成两条链表
                    // 一条下标不变的链表，一条下标+oldCap
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 循环遍历原链表上的每一个节点
                    do {
                        // 记录当前节点的下一个节点
                        next = e.next;
                        // 注意：e.hash & oldCap这一步就是前面说的判断多出的这一位是否为1
                        // 若与原容量做与运算，结果为0，表示将这个节点放入到新数组中，下标不变
                        if ((e.hash & oldCap) == 0) {
                            // 若这是不变链表的第一个节点，用loHead记录
                            if (loTail == null)
                                loHead = e;
                            // 否则，将它加入下标不变链表的尾部    
                            else    
                                loTail.next = e;
                            // 更新尾部指针指向新加入的节点    
                            loTail = e;
                        }
                        // 若与原容量做与运算，结果为1，表示将这个节点放入到新数组中，下标将改变
                        else {
                            // 若这是改变下标链表的第一个节点，用hiHead记录
                            if (hiTail == null)
                                hiHead = e;
                            // 否则，将它加入改变下标链表的尾部    
                            else
                                hiTail.next = e;
                            // 更新尾部指针指向新加入的节点    
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    // 所有节点遍历完后，判断下标不变的链表是否有节点在其中
                    if (loTail != null) {
                        // 将这条链表的最后一个节点的next指向null
                        loTail.next = null;
                        // 同时将其放入新数组的相同位置
                        newTab[j] = loHead;
                    }
                    // 另一条链表与上同理
                    if (hiTail != null) {
                        hiTail.next = null;
                        // 这条链表放入的位置要在原来的基础上加上oldCap
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

概括总结

这个resize扩容方法有两个作用。

• 首次添加元素的时候，执行的resize方法是初始化数组。
• 再次添加的元素，如果容量达到了扩容的阀值，需要进行扩容，执行的是扩容。

面试总结

HashMap什么时候才需要扩容？

当HashMap中的元素个数超过数组⼤小(数组⻓度)*loadFactor(负载因子)时，就会进行数组扩容， loadFactor的默认值(DEFAULT_LOAD_FACTOR)是0.75,这是⼀个折中的取值。也就是说，默认情况下， 数组⼤⼩为16，那么当HashMap中的元素个数超过16×0.75=12(这个值就是阈值或者边界值threshold 值)的时候，就把数组的⼤小扩展为2×16=32，即扩⼤一倍(阈值也会随之翻倍)，然后重新计算每个元素在数组中的位置，⽽这是一个⾮常耗性能的操作，所以如果我们已经预知HashMap中元素的个数，我们可以创建一个预知大小的集合，那么预知元素的个数能够有效的提高HashMap的性能。

当HashMap中的其中一个链表的对象个数如果达到了8个，此时如果数组长度没有达到64，那么 HashMap会先扩容解决，如果已经达到了了64，那么这个链表会变成红黑树，节点类型由Node变成 TreeNode类型。当然，如果映射关系被移除后，下次执行resize⽅法时判断树的节点个数低于6，也会再把树转换为链表。

进⾏扩容，会伴随着一次重新hash分配，存放位置变化了吗？

进行扩容，会伴随着一次重新hash分配，并且会遍历hash表中所有的元素，是⾮常耗时的。在编写程序中，要尽量避免resize。

HashMap在进行扩容时，使⽤的rehash⽅式非常巧妙，因为每次扩容都是翻倍，与原来计算的 (n- 1)&hash的结果相比，只是多了一个bit位，所以节点要么就在原来的位置，要么就被分配到"原位置+旧容量"这个位置。

HashMap中treeifyBin、treeify源码分析

final void treeifyBin(HashMap.Node<K,V>[] tab, int hash)将当前桶下的链表中的Node节点类型转化为TreeNode节点类型，并转换为红黑树

节点添加完成之后判断此时节点个数是否大于TREEIFY_THRESHOLD临界值8，如果大于则将链表转换为红黑树，转换红黑树的方法 treeifyBin，整体代码如下:

if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 
  // 转换为红黑树 tab表示数组名 hash表示哈希值 
  treeifyBin(tab, hash);

真的是只要TREEIFY_THRESHOLD大于临界值8就转化为红黑树吗？

(n = tab.length) < MIN_TREEIFY_CAPACITY这句源码。MIN_TREEIFY_CAPACITY的值为64。其实转换为红黑色的条件是有两个。一个条件是大于临界值8，另一个条件就是容量要大于等于64。

为什么容量要大于64才允许树形化？

如果数组很⼩，转换为红黑树，遍历效率要低很多。如果又这个条件，会进行扩容，那么就会重新计算哈希值，链表长度有可能就变短了，数据会放到数组中，这样相对来说效率⾼一些。

源码阅读

// tab数组名
// hash 表示哈希值
final void treeifyBin(Node<K,V>[] tab, int hash) {
	int n, index; Node<K,V> e;
	// 如果当前的数组为空或者数组的长度小于进行树形化的阀值64，就去扩容。而不是将节点转换为红黑树
	if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
		// 容量达不到64就去执行扩容方法
		resize();
	// 将数组中的元素取出赋值给e,e是哈希表中指定位置桶里的链表节点，从第一个开始，e:是头节点  
	else if ((e = tab[index = (n - 1) & hash]) != null) {
    // 执⾏到这⾥说明哈希表中的数组长度⼤于阈值64，开始进行树形化
		// hd红黑树的头节点，tl红黑树的尾节点
		TreeNode<K,V> hd = null, tl = null;
		// 以下这个循环就是将链表结构中的各个节点转换为数节点，也就是一串树节点，并没有转换为红黑树
		do {
			// 新创建一个树的节点，内容和当前链表节点e一致
			// 第一次的时候这个节点是一个根节点
      // 将Node节点转换为TreeNode节点
			TreeNode<K,V> p = replacementTreeNode(e, null);
			// 第一次循环的时候tl = null， 
			if (tl == null)
				// 将新创键的p节点赋值给红黑树的头结点
				hd = p;
			else {
				// p.prev = tl：将上一个节点p赋值给现在的p的前一个节点
				p.prev = tl;
				// tl.next = p;将现在节点p作为树的尾结点的下一个节点
				tl.next = p;
			}
			// 第一次循环的时候，将新创键的p节点赋值给红黑树的尾结点，此时，这个节点即是头节点也是尾节点
			tl = p;
			// e = e.next 将当前节点的下一个节点赋值给e,如果下一个节点，不等于null则回到上面继续取出链表中节点转换为红黑树    
		} while ((e = e.next) != null);
		// 让桶中的第一个元素即数组中的元素指向新建的红黑树的节点，以后这个桶里的元素就是红黑树而不是链表数据结构了
		// 将根节点放到了桶里面
		if ((tab[index] = hd) != null)
      // 转换为红黑树的真正的实现代码
			hd.treeify(tab);
	}
}

源码总结

1. 根据哈希表中元素个数确定是扩容还是树形化 。必须满足以下两个条件
2. 如果是树形化遍历桶中的元素，创建相同个数的树形节点，复制内容，建⽴起联系。
3. 然后让桶中的第⼀个元素指向新创建的树根节点，替换桶的链表内容为树形化内容。

转换为红黑树的源码分析

源码分析

// tab: 集合中的所有的Node节点,其实红黑树的第一个节点还是Node节点
final void treeify(Node<K,V>[] tab) {
	// 定义一个root节点
	TreeNode<K,V> root = null;
	// 遍历这个已经转换为树节点的链表，x指向当前节点、next指向下一个节点，首次遍历的时候这个节点就是根节点
	for (TreeNode<K,V> x = this, next; x != null; x = next) {
		// 将这个节点的下一个节点并强制转换为树节点
		next = (TreeNode<K,V>)x.next;
		// 初始化这个节点的左子树和右子树节点为null
		x.left = x.right = null;
		// 判断根节点是否为null，将当前的节点设置为根节点，也就是说有没有根节点
		// 第一次遍历，会进入这个判断，找出根节点
		if (root == null) {
			// 根节点的父节点设置为null
			x.parent = null;
			// 节点的颜色设置为黑
			x.red = false;
			// 将当前的这个节点赋值给根节点root，只有一个节点赋值成功，也就是说根节点指向当前节点
			root = x;
		}
		else {// 此时，已经存在根节点了
			// 获取当前节点的key赋值给k
			K k = x.key;
			// 获取当前节点的哈希值赋值给h
			int h = x.hash;
			// 定义key所属的Class
			Class<?> kc = null;
			// 真正的构建红黑树
			for (TreeNode<K,V> p = root;;) {
				// dir 标识方向，是在根节点的左侧还是右侧
				// ph标识当前树节点的hash值
				int dir, ph;
				// 当前根节点的key赋值给pk
				K pk = p.key;
				// 将根节点hash赋值给ph,如果当前根节点hash值大于当前链表节点的hash值
				if ((ph = p.hash) > h)
					// 标识当前链表节点会放到当前根节点的左侧
					dir = -1;
					// 将根节点hash赋值给ph,如果当前根节点hash值小于当前链表节点的hash值
				else if (ph < h)
					// 标识当前链表节点会放到当前根节点的右侧
					dir = 1;
					// 将根节点hash赋值给ph,如果当前根节点hash值等于当前链表节点的hash值
					// 如果当前链表节点的key实现了comparable接口，并且当前树节点和链表节点是相同Class的实例
					// 那么通过comparable的方式再比较两者。
					// 如果还是相等，最后再通过tieBreakOrder比较一次
					// dir = compareComparables(kc, k, pk)) == 0等于0代表还是平衡
				else if ((kc == null && (kc = comparableClassFor(k)) == null) ||
						(dir = compareComparables(kc, k, pk)) == 0)
					// 打破平衡
					dir = tieBreakOrder(k, pk);

				// 当前节点
				TreeNode<K,V> xp = p;
				// dir <= 0:当前链表节点放置在当前树节点的左侧，但不一定是该树节点的左子树，也可能是左子树的右子树或者更深层次的节点。
				// dir > 0:当前链表节点放置在当前树节点的右侧，但不一定是该树节点的右子树，也可能是右子树的左子树或者更深层次的节点。
				// 如果当前树节点不是叶子节点，那么最终会以当前树节点的左子树或者右子树为起始节点接着遍历，重新寻找自己（当前链表节点）的位置
				// 如果当前树节点就是叶子节点，那么根据dir的值，就可以把当前链表节点挂载到当前树节点的左或者右侧了。
				// 挂载之后，还需要重新把树进行平衡。平衡之后，就可以针对下一个链表节点进行处理了。
				if ((p = (dir <= 0) ? p.left : p.right) == null) {
					// 当前链表节点作为当前树节点的子节点
					x.parent = xp;
					if (dir <= 0)
						// 左子树
						xp.left = x;
					else
						// 右子树
						xp.right = x;
					// 插入一个节点后，调整红黑树
					root = balanceInsertion(root, x);
					break;
				}
			}
		}
	}
	// 链表节点都遍历完后，最终构造出来的树可能经历多次平衡操作，根节点目前到底是链表的哪一个节点是不确定的。
	// 要将红黑树的根节点移动至链表节点的第一个位置也就是 table[i]的位置。
	moveRootToFront(tab, root);
}