java集合之HashMap的扩容resize

JDK1.7中,resize时,index取得时,全部采用重新hash的方式进行了。JDK1.8对这个进行了改善。

以前要确定index的时候用的是(e.hash & oldCap-1),是取模取余,而这里用到的是(e.hash & oldCap),它有两种结果,一个是0,一个是oldCap,

比如oldCap=8,hash是3,11,19,27时,(e.hash & oldCap)的结果是0,8,0,8,这样3,19组成新的链表,index为3;而11,27组成新的链表,新分配的index为3+8;

JDK1.7中重写hash是(e.hash & newCap-1),也就是3,11,19,27对16取余,也是3,11,3,11,和上面的结果一样,但是index为3的链表是19,3,index为3+8的链表是

27,11,也就是说1.7中经过resize后数据的顺序变成了倒叙,而1.8没有改变顺序。


原理:

我们使用的是2次幂的扩展(指长度扩为原来2倍),所以,元素的位置要么是在原位置,要么是在原位置再移动2次幂的位置。看下图可以明白这句话的意思,n为table的长度,图(a)表示扩容前的key1和key2两种key确定索引位置的示例,图(b)表示扩容后key1和key2两种key确定索引位置的示例,其中hash1是key1对应的哈希与高位运算结果。

hashMap 1.8 哈希算法例图1

元素在重新计算hash之后,因为n变为2倍,那么n-1的mask范围在高位多1bit(红色),因此新的index就会发生这样的变化:

hashMap 1.8 哈希算法例图2

因此,我们在扩充HashMap的时候,不需要像JDK1.7的实现那样重新计算hash,只需要看看原来的hash值新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap”,可以看看下图为16扩充为32的resize示意图:

jdk1.8 hashMap扩容例图

这个设计确实非常的巧妙,既省去了重新计算hash值的时间,而且同时,由于新增的1bit是0还是1可以认为是随机的,因此resize的过程,均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别,JDK1.7中rehash的时候,旧链表迁移新链表的时候,如果在新表的数组索引位置相同,则链表元素会倒置,但是从上图可以看出,JDK1.8不会倒置。

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;
        	if (oldCap > 0) {
        		// 超过最大值就不再扩充了,就只好随你碰撞去吧
        		if (oldCap >= MAXIMUM_CAPACITY) {
        			threshold = Integer.MAX_VALUE;
        			eturn oldTab;
        		}
        		// 没超过最大值,就扩充为原来的2倍
        		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 {
        			// zero initial threshold signifies using defaults
        			newCap = DEFAULT_INITIAL_CAPACITY;
        			newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        		}
        		// 计算新的resize上限
        		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) {
        			// 把每个bucket都移动到新的buckets中
        			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 { // 链表优化重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;
        							}
        							// 原索引+oldCap
        							else {
        								if (hiTail == null)
        									hiHead = e;
        								else
        									hiTail.next = e;
        								hiTail = e;
        							}
        						} while ((e = next) != null);
        						// 原索引放到bucket里
        						if (loTail != null) {
        							loTail.next = null;
        							newTab[j] = loHead;
        						}
        						// 原索引+oldCap放到bucket里
        						if (hiTail != null) {
        							hiTail.next = null;
        							newTab[j + oldCap] = hiHead;
        						}
        					}
        				}
        			}
        		}
        		return newTab;
        	}
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
            TreeNode<K,V> b = this;
            // Relink into lo and hi lists, preserving order
            TreeNode<K,V> loHead = null, loTail = null;
            TreeNode<K,V> hiHead = null, hiTail = null;
            int lc = 0, hc = 0;
            for (TreeNode<K,V> e = b, next; e != null; e = next) {
                next = (TreeNode<K,V>)e.next;
                e.next = null;
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                    ++lc;
                }
                else {
                    if ((e.prev = hiTail) == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    ++hc;
                }
            }

            if (loHead != null) {
                if (lc <= UNTREEIFY_THRESHOLD)
                    tab[index] = loHead.untreeify(map);
                else {
                    tab[index] = loHead;
                    if (hiHead != null) // (else is already treeified)
                        loHead.treeify(tab);
                }
            }
            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }
        }



&lt;&lt; `HashMap` 是 Java 集合框架中的重要组成部分之一,用于存储键值对(key-value pairs)。当 `HashMap` 中的数据量超过其容量限制时,就需要进行扩容操作。下面是关于 `HashMap` 扩容机制的具体介绍。 ### HashMap扩容过程 1. **初始状态**: - 当创建一个新的 `HashMap` 对象时,默认的初始化容量为 16(即底层数组大小为 16),加载因子默认为 0.75。 - 公式:threshold = 容量 * 加载因子 ```java int threshold = (int)(capacity * loadFactor); ``` 初始阈值为 12 (`16 * 0.75`),这意味着如果当前元素数量达到或超过该阈值,则触发扩容操作。 2. **扩容时机**: - 每次向 `HashMap` 插入新数据之前都会检查是否满足以下条件: 如果 `size &gt;= threshold` (其中 size 表示实际包含的有效键值对数目),则执行扩容逻辑。 3. **扩容步骤**: - 创建新的更大的底层数组。通常情况下会将原数组长度翻倍,并重新计算 hash 值以分配到新位置上。(假设原来 capacity=16, 新容量变为 32) - 将旧表中的所有条目逐一迁移到新的大数组中去。 4. **迁移过程中可能遇到的问题及处理方式**: - 在 JDK8 及之后版本里优化了链表结构,在大量冲突的情况下使用红黑树替代普通单向链表形式;此外还有其他细节上的改进如 CAS 循环等保证线程安全等问题不再赘述。 ```java import java.util.HashMap; public class Test { public static void main(String[] args) throws Exception{ // 构造一个空的HashMap实例 HashMap&lt;Integer,Integer&gt; map=new HashMap&lt;&gt;(8,(float)0.5); System.out.println(&quot;Initial Threshold:&quot;+map.threshold()); for(int i=0;i&lt;9;i++){ if(i==8){ System.out.println(&quot;\nBefore putting key &quot;+i+&quot;, table is :&quot;); printTable(map.table); //Put will trigger resize here since current entries count reaches to the initial threshold value. map.put(i,i*10); System.out.println(&quot;\nAfter Resize operation:&quot;); printTable(map.table); }else { map.put(i,i*10); } } } private static &lt;K,V&gt;void printTable(Entry&lt;K,V&gt;[] tab){ Entry&lt;K,V&gt; e; int idx=0; while(idx &lt;tab.length ){ e=tab[idx++]; if(e!=null){ do{ System.out.printf(&quot;[%d]=%s -&gt; &quot;,idx-1,e.value ); e=e.next; }while(e != null ); System.out.print(&quot;null\n&quot;); } else{System.out.printf(&quot;[%d]=null\n&quot;,idx-1);} } } } ``` 上述程序演示了一个自定义的小型测试用例展示如何打印出每次插入前后的内部哈希桶分布情况以及触发重置的过程。需要注意的是这里简化了一些实现细节方便理解原理即可。 ### 解释: - 在上面的例子中我们手动设定了较小的初始容量与较低负载因子从而加快出现扩容现象以便观察效果; - 方法 `printTable()` 展现现有表格布局状况包括每个索引处是否有节点链接形成链条等情况便于追踪整个变化轨迹。 - 第九次调用put()方法的时候因为已经达到预设门限所以开始扩展空间并将已有内容复制过去调整后的位置。
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值