JDK源码-HashMap-resize扩容方法(JDK7和JDK8)

扩容操作可以认为是HashMap源码中最复杂的
resize方法的不是public的,不能通过client触发,所以只能直接进入源码查看

JDK 7

void resize(int newCapacity) {
	Entry[] oldTable = table;
	int oldCapacity = oldTable.length;
	if (oldCapacity == MAXIMUM_CAPACITY) {
		threshold = Integer.MAX_VALUE;
		return;
	}

	Entry[] newTable = new Entry[newCapacity];
	boolean oldAltHashing = useAltHashing;
	useAltHashing |= sun.misc.VM.isBooted() &&
			(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
	boolean rehash = oldAltHashing ^ useAltHashing;//判断是否需要对原node重新hash定位table的index
	transfer(newTable, rehash); //扩容核心方法
	table = newTable;
	threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}

进入 transfer 方法

void transfer(Entry[] newTable, boolean rehash) {
	int newCapacity = newTable.length;
	for (Entry<K,V> e : table) {//直接遍历table变量
		//链表跟table[i]断裂遍历,头部往后遍历插入到newTable中
		while(null != e) {
			Entry<K,V> next = e.next;
			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;
		}
	}
}

扩容过程总结:
创建一个新的数组newTable,容量是oldTable的一倍
遍历oldTable,拿到每个链表
遍历链表,头插法插入newTable


JDK 8

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; //扩容阈值也翻倍
	}
	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) {//开始遍历oldTable
			Node<K,V> e;
			if ((e = oldTab[j]) != null) {
				oldTab[j] = null;
				if (e.next == null) //table[i]没值
					newTab[e.hash & (newCap - 1)] = e;
				else if (e instanceof TreeNode) //table[i]是红黑树的结构
					((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
				else { //table[i]是链表的结构,扩容后还是保持顺序的
					Node<K,V> loHead = null, loTail = null; //“低链表”的头和尾,即扩容后的在new table的index和old index是一样的
					Node<K,V> hiHead = null, hiTail = null; //“高链表”的头和尾,即扩容后的在new table的index是old index的2倍
					Node<K,V> next;
					do {
						next = e.next;
						if ((e.hash & oldCap) == 0) {//newTable index ==  oldTable index
							if (loTail == null)
								loHead = e;//头只当初始时才赋值
							else
								loTail.next = e;//新插入的都到添加到tail中
							loTail = e;
						}
						else {//newTable index ==  oldTable index * 2
							if (hiTail == null)
								hiHead = e;//头只当初始时才赋值
							else
								hiTail.next = e;//新插入的都到添加到tail中
							hiTail = e;
						}
					} while ((e = next) != null);
					if (loTail != null) { //将“低链表”添加到newTable中
						loTail.next = null;
						newTab[j] = loHead;
					}
					if (hiTail != null) {//将“高链表”添加到newTable中
						hiTail.next = null;
						newTab[j + oldCap] = hiHead;
					}
				}
			}
		}
	}
	return newTab;
}

总结(先针对链表操作的总结,红黑树的后续文章会写):
如果是链表处理(红黑树的后续文章讨论),那么就将oldTable[i]分成高低链表,生成后插入到newTable中


对比

JDK7是每拿到一个Node就直接插入到newTable,而JDK8是先插入到高低链表中,然后再一次性插入到newTable。
所以链表的扩容过程JDK7会出现死循环问题,而JDK8避免了这个问题。
JDK8跟原先的链表对比Node之间顺序是一致的,而JDK7是是反过来的。

<think>嗯,用户让我介绍一下JDK8HashMap源码。首先,我得先回想一下HashMap的基本结构。在JDK8之前,HashMap是数组加链表的结构,当哈希冲突较多时,链表会变得很长,查询效率会下降。而JDK8之后,当链表长度超过8时,会转为红黑树,这样查询的时间复杂度就从O(n)变成O(log n)了。这个优化应该是个重点。 接下来,我需要考虑HashMap的几个核心部分:数据结构、哈希计算、put方法扩容机制、红黑树转换条件等。用户可能对这些部分感兴趣,特别是之前版本不同的地方,比如红黑树的引入。 然后,数据结构方面,HashMap内部有一个Node数组,每个Node可能是一个链表节点或者树节点。需要解释一下Node类的结构,包括hash、key、value、next这些属性。当链表转成树时,会用TreeNode,这可能继承自LinkedHashMap的Entry,但具体的继承关系可能需要查证一下。 哈希计算方面,JDK8的hash方法做了优化,将高位的信息也参与到索引的计算中,减少哈希冲突。具体来说,hashCode()的高16位低16位进行异或,这样在数组长度较小时,高位的变化也能影响最终的索引位置,减少碰撞。 put方法的流程是关键。当插入一个键值对时,首先计算哈希值,找到数组下标。如果该位置为空,直接插入;如果是链表或树节点,则遍历查找是否存在相同的key,存在则替换,否则添加到链表末尾或树中。当链表长度达到8且数组长度大于等于64时,链表转红黑树,否则进行扩容。这个阈值需要注意,可能用户会问到为什么是8或者64。 扩容机制,也就是resize方法。当元素数量超过容量乘以负载因子时,数组会扩容为原来的两倍。扩容后,原来的节点会重新计算位置,要么在原位置,要么原位置+旧容量。这里可能涉及到高位判断,通过(e.hash & oldCap)是否为0来决定位置。同时,在JDK8中,链表在扩容时会被拆分成两个链表,保持顺序,避免死循环的问题,而JDK7之前可能因为头插法导致死循环。 线程安全方面,HashMap不是线程安全的,多线程环境下可能出现问题,比如数据覆盖、死循环(在JDK7中)等。需要提到ConcurrentHashMap或者使用Collections.synchronizedMap来保证线程安全。 另外,初始容量负载因子的默认值,初始容量是16,负载因子0.75,这些参数的作用调整的影响也需要解释一下。比如负载因子高可以减少空间开销,但增加查找成本;负载因子低则相反。 红黑树转换的条件需要明确,链表长度超过8且数组长度至少64才会转换,否则只是扩容。这是为了避免在哈希表还很小的时候,不必要的树化,因为扩容可能更有效。 可能用户还想知道源码中的一些具体实现细节,比如TreeNode的结构,红黑树的插入、删除操作是如何实现的,但可能这部分太深入,需要根据用户的背景决定是否展开。 在解释的时候,需要注意避免过于技术化的术语,用比较易懂的语言,同时结合代码结构,比如putVal方法resize方法的关键步骤。可能还需要提到modCount用于快速失败机制,迭代器在检测到结构变化时抛出异常。 用户可能的疑问点包括:为什么选择红黑树而不是其他数据结构?为什么阈值是8扩容为什么是两倍?这些可能需要准备答案,比如红黑树在查询插入之间取得平衡,阈值8是基于泊松分布统计,两倍扩容是为了保持容量为2的幂,方便位运算计算索引。 总结下来,应该按照数据结构、哈希计算、put流程、扩容机制、树化条件、线程安全等方面来组织回答,重点突出JDK8的改进,比如红黑树的引入扩容优化。</think>在 JDK8 中,`HashMap` 是一个基于哈希表实现的键值对容器,其源码设计在性能数据结构上进行了优化(如引入红黑树)。以下是对其核心实现的介绍: --- ### **1. 数据结构** JDK8 的 `HashMap` 使用 **数组 + 链表 + 红黑树** 的复合结构: - **数组(`Node<K,V>[] table`)**:存储链表的头节点或红黑树的根节点。 - **链表(Node)**:解决哈希冲突的基础结构,每个节点存储键值对下一个节点的引用。 - **红黑树(TreeNode)**:当链表长度超过阈值(默认 8)且数组长度 ≥ 64 时,链表转换为红黑树,提升查询效率。 ```java static class Node<K,V> implements Map.Entry<K,V> { final int hash; // 哈希值 final K key; V value; Node<K,V> next; // 链表的下一个节点 } ``` -- ### **2. 哈希计算** 通过 `hash()` 方法将键的哈希码分散到数组中,减少碰撞: ```java static final int hash(Object key) { int h; // 高16位与低16位异或,增加低位的随机性 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); } ``` -- ### **3. `put()` 方法流程** 1. **计算哈希值**:根据 `key` 计算哈希值,确定数组下标 `(n-1) & hash`。 2. **处理空桶**:若目标位置为空,直接插入新节点。 3. **处理冲突**: - **链表**:遍历链表,若 `key` 已存在则更新值,否则添加到链表尾部。 - **红黑树**:调用树的插入方法。 4. **树化检查**:链表长度 ≥ 8 时尝试树化(需数组长度 ≥ 64,否则优先扩容)。 5. **扩容检查**:元素总数超过 `容量 * 负载因子`(默认 0.75)时触发扩容--- ### **4. 扩容机制(`resize()`)** - **新容量**:原容量的 2 倍(保持为 2 的幂)。 - **数据迁移**: - 链表节点根据 `(e.hash & oldCap)` 是否为 0 分配到原位置或新位置。 - 红黑树节点会拆分为两个链表,若长度 ≤ 6 则退化为链表。 -- ### **5. 红黑树转换条件** - **链表 → 红黑树**:链表长度 ≥ 8 **且** 数组长度 ≥ 64。 - **红黑树 → 链表**:树节点数 ≤ 6 时退化为链表。 --- ### **6. 关键参数** - **默认初始容量**:16。 - **负载因子(`loadFactor`)**:默认 0.75(平衡空间与时间效率)。 - **扩容阈值**:`容量 * 负载因子`。 - **树化阈值**:链表长度 ≥ 8,数组长度 ≥ 64。 --- ### **7. 线程安全性** `HashMap` **非线程安全**,多线程操作可能导致数据不一致。替代方案: - 使用 `ConcurrentHashMap`。 - 通过 `Collections.synchronizedMap()` 包装。 -- ### **8. 性能优化点** - **红黑树**:避免长链表的低效查询(时间复杂度从 O(n) 优化到 O(log n))。 - **高位异或哈希**:减少哈希碰撞。 - **扩容优化**:避免 JDK7 及之前版本的头插法导致的死循环问题。 -- ### **源码分析示例(简化的 `put()` 流程)** ```java 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) { 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 { // 处理哈希冲突... } // 检查扩容... } ``` --- 通过以上设计,JDK8 的 `HashMap` 在高并发高负载场景下显著提升了性能,同时保持了合理的空间利用率。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值