数据结构-HashMap核心学习之首章

数据结构-HashMap核心学习之首章

Android小彩虹2021-08-20 3:40:09290A+A-

前言

​ 本文的解析基于JAVA8,由于HashMap内部机制较为复杂,本章介绍HashMap的下标计算过程和resize()函数。包含空间开辟,特征保留,冲突分析,链表重组原理等内容。

1.下标计算

计算key.hashCode()并将哈希值的高位与低位做异或

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

JAVA7之中其实是四次异或,在JAVA8之中已经做了简化了。其原理是不变的

  • 首先要说明的是key.hashCode()函数调用的是key自带的哈希函数,返回Int型散列值,但是如果直接拿散列值作为下标访问HashMap数组的话,映射空间就为**-21474836482147483648**,即为40亿的映射空间,但是这个长度的数组内存是放不下的。所以要对数组的长度取模运算。即散列值和数组的长度-1做操作,代码如下。
(n - 1) & hash

n为length

  • 其次要说明的是为什么HashMap的长度要取2的整次幂,因为长度-1正好相当于一个低位掩码。“与”操作的结果就是散列值的高位全部归零,只保留低位值,用来做数组下标访问。以初始长度16为例,16-1=15。2进制表示是00000000 00000000 00000000 00001111。和某散列值做操作如下,结果就是截取了最低的四位值。过程如下。
				11011111 01111110 10101111 11010101
		&		00000000 00000000 00000000 00001111(n-1)
		------------------------------------------------------
				00000000 00000000 00000000 00000101
  • 根据结果看到,其实保留的就是最低的四位值。如果直接拿此值去当作下标,显然碰撞会十分严重。如果是等差数列形的分布,最后几位为规律性重复,则误解。此时扰乱函数的作用就体现出了。过程如下。
step1:调用key.hashCode()并复制给h
			11011111 01111110 10101111 11010101 [h = key.hashCode()]
------------------------------------------------------------------
step2:将h的高位与低位做异或(与无符号右移的h做异或)
			11011111 01111110 10101111 11010101 [h]
		 	00000000 00000000 11011111 01111110 [h >>> 16]
		 	00000000 00000000 01110000 10101011 ^
------------------------------------------------------------------
step3:将结果与n(数组长度)-1做与
			00000000 00000000 01110000 10101011
			00000000 00000000 00000000 00001111	&  	    
------------------------------------------------------------------
			00000000 00000000 00000000 00001011
  • 扰乱函数很巧妙的通过16位无符号右移,让自己的高低位做异或,使高低位做特征对比,保留了部分高位的特征,也加大了结果的随机性。然后与(n-1)做与操作,结果也就是保留了最低的四位。

最后在引用一篇An introduction to optimising a hashing strategy。作者随机选取了352个字符串,在他们散列值完全没有冲突的前提下,对它们做低位掩码,取数组下标。结果如下。

当HashMap长度为512位,如果取低9位,没有扰动函数,有103次碰撞。加入扰乱函数则降低为92次。减少近10%

JAVA8把扰乱函数从四次降低为一次,侧面印证了多做几次意义不大。

2.resize()

​ resize()内部逻辑还是较为复杂的,我们把方法分为多个部分,我们分段解析。

final Node<K,V>[] resize() {
    	//------1.空间开辟begin------
        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; // 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);
        }
        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;
    	//------1.空间开辟end------
    
    	//------2.重新分配节点到对应位置begin------
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //------2.1数组分配begin------
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    //------2.1数组分配end------
                    
                    //------2.2红黑树分配begin------
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //------2.2红黑树分配end------
                    
                    //------2.3链表分配begin------
                    else { // preserve order
                        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;
                        }
                    }
                }
                //------2.3链表分配end------
            }
        }
        return newTab;
    	//------2.重新分配节点到对应位置end------
}

此段代码是reseize()方法全貌,我们分为如下几个分段:

  • 重新开辟容量大小计算过程
  • 重新分配节点到对应位置
    • 数组分配
    • 红黑树分配
    • 链表分配

1.创建新数组

​ 在HashMap初始化和扩容的时候都会调用此方法,首先第一段为根据具体情况计算出需要创建的HashMap的容量和扩容阈值。下文解析会围绕两种情况做出分析。

//1为无initialCapacity初始化容量
//2为指定了initialCapacity初始化容量
//3为扩容
//获取旧table的引用,长度,容量,扩容阈值
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
//创建新的容量,阈值的变量
int newCap, newThr = 0;
if (oldCap > 0) {
    //3
    if (oldCap >= MAXIMUM_CAPACITY) {
        //如果旧容量大于容量最大限制则给扩容阈值设置为Integer.MAX_VALUE
    	//并返回旧table
         threshold = Integer.MAX_VALUE;
         return oldTab;
    }
    else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
        //3
        //对新容量赋值为旧容量的2倍
    	//如果新容量小于容量最大限制,并且旧容量大于或等于默认容量(16)则给新扩容阈值同赋值为旧容量的2倍
         newThr = oldThr << 1;
}else if (oldThr > 0) 
    //2
	//如果指定了initialCapacity,则threshold为大于initialCapacity的最小的2的次幂
	//(oldThr > 0)为如果指定了initialCapacity,则用threshold作为table的实际大小
    newCap = oldThr;
else { 
     //1
     //如果没有指定initialCapacity,则为默认空间大小
	 //并且扩容阈值赋值为扩容因子*默认空间大小
     newCap = DEFAULT_INITIAL_CAPACITY;
     newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) { 
     //1
     //为扩容阈值赋值为新容量的0.75倍(小于最大容量的情况)
     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;

最后总结如下

  • 如果在初始化情况下,并构造函数没有指定initialCapacity,则进入分支1,table大小为16,扩容阈值为16*0.75。
  • 如果在初始化情况下,并构造函数指定了initialCapacity,则进入分支2,则table大小为threshold, 即大于指定initialCapacity的最小的2的整数次幂。
  • 如果是扩容情况,则进入分支3,对新容量赋值为旧容量的2倍。

2.赋值过程

2.1 纯数组情况

​ 赋值过程其实是通过节点迭代完成的,只不过内部有分为三种情况处理,我们本段解析先说明是如何通过next添加到纯数组的结构(也就是没有hash冲撞的情况)。

if (oldTab != null) {
    for (int j = 0; j < oldCap; ++j) {
        //创建节点
        Node<K,V> e;
        //e赋值迭代节点
        if ((e = oldTab[j]) != null) {
            //如果迭代的节点不NULL
            //给迭代节点制空,CG回收
            oldTab[j] = null;
            if (e.next == null) newTab[e.hash & (newCap - 1)] = e;//如果e节点的.next节点为空,则为纯数组,直接通过下标添加。
        }
        //后续代码从此继续
    }
}

2.2 链表情况

​ 此段代码极为复杂,首先先说出大体的逻辑。

  1. 根据上文分析,如果next节点为空则等于在此下标下有多个元素(链表结构),并且不等于红黑树会进入此分支
  2. 下段代码会通过某种方式确定新HashMap(扩容后的HashMap)那些节点是下标没有发生变化的,那些是发生变化的,并根据放置到两组不同的链表之中。
  3. 最终通过某种方式把两组链表添加至两个对应下标

此时我们有两个问题

  • 插入到不同链表的条件?
  • 如何计算两组链表要添加到的下标?
![2076773863-5b5e7d6916752_articlex](C:\Users\D\Desktop\2076773863-5b5e7d6916752_articlex.png)//lo链表的头节点和尾节点
Node<K,V> loHead = null, loTail = null;
//hi链表的头节点和尾节点
Node<K,V> hiHead = null, hiTail = null;
//迭代节点
Node<K,V> next;
do {
   next = e.next;
   if ((e.hash & oldCap) == 0) {//关键点
       //插入至lo链表
       if (loTail == null)
            loHead = e;
       else
            loTail.next = e;
       loTail = e;
   }
   else {
       //插入到hi链表
       if (hiTail == null)
            hiHead = e;
       else
            hiTail.next = e;
       hiTail = e;
   }
} while ((e = next) != null);
if (loTail != null) {
   //如果lo链表不为空则添加到[j]位
   loTail.next = null;
   newTab[j] = loHead;
}
if (hiTail != null) {
   //如果hi链表不为空则添加到[j+oldCap]位
   hiTail.next = null;
   newTab[j + oldCap] = hiHead;
}

根据源码分析,得到结果。

  • ((e.hash & oldCap) == 0)将节点插入到lo链表,否则添加到hi链表。下文做出此条件的分析。

    首先要明确几点:

    1. oldCap一定是2的整数次幂, 假设是2^m
    2. newCap是oldCap的两倍, 则会是2^(m+1)
    3. hash对数组大小取模**(n - 1) & hash** 其实就是取hash的m

    所以假设oldCap为32,newCap为64,即:

    oldCap=32		
    oldCap-1=31		0000 0000 0000 0000 0000 0000 0001 1111
    ----------------------------------------------------------------------
    newCap=64
    newCap-1=63		0000 0000 0000 0000 0000 0000 0011 1111
    

    此时,(newCap-1&hash)的结果只可能是首位是0或者是1加任意四位0或1,假设结果是011010和111010两种情况,得出以下两种结论。

    • 结果为011010则和(oldCap-1&hash)结果一致,即位置不变,为lo链表,下标为j
    • 结果为111010则和(oldCap-1&hash)+10000一致,即位置发生变化,hi链表,下标为j+oldcap

    图解如下

点击这里复制本文地址 以上内容由权冠洲的博客整理呈现,请务必在转载分享时注明本文地址!如对内容有疑问,请联系我们,谢谢!

支持Ctrl+Enter提交

联系我们| 本站介绍| 留言建议 | 交换友链 | 域名展示 | 支付宝红包
本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除

权冠洲的博客 © All Rights Reserved.  Copyright quanguanzhou.top All Rights Reserved
苏公网安备 32030302000848号   苏ICP备20033101号-1
本网站由 提供CDN/云存储服务

联系我们