继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持,我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

关于HashMap的几道面试题

霜花似雪
关注TA
已关注
手记 163
粉丝 1.5万
获赞 8507

http://img3.mukewang.com/5e91f53600016c5a08260496.jpg

1. 为什么我们建议在定义HashMap的时候,就指定它的初始化大小呢?

答:在当我们对HashMap初始化时,如果没有为其设置初始化容量,那么系统会默认创建一个容量为16的大小的集合。当我们向HashMap中添加元素时,如果HashMap的容量值超过了它的临界值(默认16*0.75=12)时,(0.75是HashMap的加载因子)HashMap将会重新扩容到下一个2的指数次幂(2^4=16 下一个2的指数次幂是2^5=32)。由于HashMap扩容要进行resize的操作,频繁的resize,会导致HashMap的性能下降,所以建议在确定HashMap集合的大小的情况下,指定其初始化大小,避免做过多的resize操作,导致性能下降。

 

2. HashMap什么时候进行扩容?

答:当我们不断的向HashMap中添加元素时,它会判断HashMap当前的容量值(当前元素的个数)是否超过了它的临界值(在没有指定其初始化大小时,默认16*0.75=12),如果添加的元素个数超过了临界值,它就会开始进行扩容。

 

3. HashMap在扩容时,扩容到多大?

答:HashMap在扩容时,它会扩容到下一个2的指数次幂,即当前容量的2倍,比如当前容量是2^4=16,将会扩容到下一个2的指数次幂2^5=32.

 

4. HashMap是如何进行扩容的?

答:HashMap进行扩容时会调用resize()函数,重新计算HashMap所需的新的容量,然后重新定义一个新的容器,将原数组数据进行Hash, 放入新的容器中。这个过程将会导致HashMap的性能下降。

resize()函数的源码:

//HashMap 扩容操作
final Node<K,V>[] resize() {
    //保存当前table
    Node<K,V>[] oldTab = table;
   //保存当前table的容量
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
   //保存当前阈值
    int oldThr = threshold;
   //初始化新的table容量和阈值
    int newCap, newThr = 0;
   
   //1. resize()函数在size(HashMap当前的元素个数) > threshold(当前阈值,默认16*0.75=12)时调用。
   //当oldCap(HashMap的元素个数)大于0表示原来的table表非空,oldCap(threshold)为oldCap x load_factor(加载因子:0.75)
    if (oldCap > 0) {
       //若旧table容量大于等于最大容量,更新阈值为Integer.MAX_VALUE(最大整形值),这样以后就不会自动扩容了
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
      //扩容到下一个2的指数次幂,容量翻倍,使用左移,效率更高
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold  //阈值翻倍
    }
   
   //2. resize()函数在table为空被调用。oldCap小于等于0且oldThr大于0,表示用户使用HashMap的构造函数创建了一个HashMap,
   //使用的构造函数为HashMap(int initialCapacity, float loadFactor)或HashMap(int initialCapacity)或HashMap(Map<? extends K, ? extends V> m),
   //导致了oldTab为null,oldCap为0,oldThr为用户指定的HashMap的初始化容量
    else if (oldThr > 0) // initial capacity was placed in threshold
        newCap = oldThr;  //当table没有初始化时,threshold为初始容量, threshold = tableSizeFor(t);
   
   //3. resize()函数在table为空被调用。oldCap小于等于0且oldThr大于0,表示用户使用HashMap的无参构造函数HashMap()函数创建了一个HashMap,
   //此时,所有值均采用默认值,oldTab(table)表为空,oldCap为0,oldThr等于0.
    else {               // zero initial threshold signifies using defaults
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
   //如果新的阈值为0
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;  //新的tbale容量*加载因子
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
       //初始化table
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
       //把oldTab中的节点reHash到newTab中去
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
            //如果节点是单个节点,直接在newTab中进行重定位
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
            //如果节点是TreeNode节点,要进行红黑树的rehash操作
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
            //如果是链表,进行链表的rehash操作
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
               //将同一桶中的元素根据(e.hash & oldCap)是否为0进行分割,分成两个不同的链表,完成rehash操作
                    do {
                        next = e.next;
                  //根据算法  e.hash & oldCap 判断节点位置rehash后是否发生改变,最高位==0,这是索引不变的链表
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                  //最高位==1,这是索引发生改变的链表
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {  //原bucket位置的尾指针不为空(即还有node)
                        loTail.next = null;   //链表最后一个节点为null
                        newTab[j] = loHead;  //链表的头指针放在新桶的相同下标(j)处
                    }
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;  //rehash后节点新的位置一定为原来基础上加上oldCap
                    }
                }
            }
        }
    }
    return newTab;
}

 

5. 为什么说HashMap是线程不安全的?

答:HashMap在多线程并发时线程不安全,主要表现在下面两个方面:

(1)当向HashMap中put(添加)元素时导致的多线程数据不一致

比如有两个线程 A 和 B ,首先 A 希望插入一个 key-value键值对到HashMap 中,它首先计算记录所要落到的 hash 桶的索引坐标,然后获取到该桶里面的链表头结点,此时线程 A 的时间片用完了,而此时线程 B 被调度得以执行,和线程 A 一样执行,只不过线程 B 成功将记录插到了桶里面。假设线程 A 插入的记录计算出来的 hash 桶索引和线程 B 要插入的记录计算出来的 hash 桶索引是一样的,那么当线程 B 成功插入之后,线程 A 再次被调度运行时,它依然持有过期的链表头但是它对此一无所知,以至于它认为它应该这样做,如此一来就覆盖了线程 B 插入的记录,这样线程 B 插入的记录就凭空消失了,造成了数据不一致的行为。

简单来说就是在多线程环境下,向HashMap集合中添加元素会存在覆盖的现象,导致了线程不安全。

 

(2)当HashMap进行扩容调用resize()函数时引起死循环

HashMap在put的时候,插入的元素超过了容量(由负载因子决定)的范围就会触发扩容操作,就是rehash,这个会重新将原数组的内容重新hash到新的扩容数组中,在多线程的环境下,存在同时其他的元素也在进行put操作,如果hash值相同,可能出现同时在同一数组下用链表表示,造成闭环,导致在get时会出现死循环,所以HashMap是线程不安全的。

HashMap的线程不安全主要体现在下面两个方面:
1.在JDK1.7中,当并发执行扩容操作时会造成环形链和数据丢失的情况。
2.在JDK1.8中,在并发执行put操作时会发生数据覆盖的情况。

 

6. 说说HashMap 的数据结构

HashMap是一个key-value键值对的数据结构,从结构上来讲在jdk1.8之前是用数组加链表的方式实现,jdk1.8加了红黑树,HashMap数组的默认初始长度是16,HashMap数组只允许一个key为null,允许多个value为null

HashMap的内部实现,HashMap是使用数组+链表+红黑树的形式实现的,其中数组是一个一个Node[]数组,我们叫他hash桶数组,它上面存放的是key-value键值对的节点。HashMap是用hash表来存储的,在HashMap里为解决hash冲突,使用链地址法,简单来说就是数组加链表的形式来解决,当数据被hash后,得到数组下标,把数据放在对应下标的链表中。

 

HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作,并允许使用null值和null键。此类不保证映射的顺序,特别是它不保证该顺序恒久不变。HashMap实际上是一个“链表散列”的数据结构,即数组和链表的结合体。HashMap底层就是一个数组结构,数组中的每一项又是一个链表。当新建一个HashMap的时候,就会初始化一个数组。HashMap主干为一个Entry数组,而每个Entry存放着一个键值对和同时指向另一个Entry的引用,如果发生哈希冲突,该引用即指向另一个Entry。

HashMap是由数组+链表结构组成,数组是HashMap主体,链表则是为了解决哈希冲突而存在,如果对于Entry不含链表的位置,对其操作的时间复杂度为O(1),如果定位到具有链表的位置,则时间复杂度为O(n)。

 

HashMap中重要字段:

transient int size :实际储存的KEY-VALUE对个数

int threshold :阀值,当表为空的时候,该值初始容量为16,后期扩容使用

final float loadFactor :负载因子,代表表的填充度,默认为0.75

transient int modCount : 用于快速失败,迭代时抛出异常

在JDK1.8中 HashMap底层改为链表+数组+红黑树的形式,当Hash冲突多次在同一个位置发生的时候,(确切的说是该位置链表长度大于8时),在此位置将用红黑树来储存数据提高读取效率.

HashMap 包含如下几个构造器:

HashMap():构建一个初始容量为 16,负载因子为 0.75 的 HashMap。

HashMap(int initialCapacity):构建一个初始容量为 initialCapacity,负载因子为 0.75 的 HashMap。

HashMap(int initialCapacity, float loadFactor):以指定初始容量、指定的负载因子创建一个 HashMap。

HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数,它们是初始容量initialCapacity和负载因子loadFactor。

负载因子loadFactor衡量的是一个散列表的空间的使用程度,负载因子越大表示散列表的装填程度越高,反之愈小。对于使用链表法的散列表来说,查找一个元素的平均时间是O(1+a),因此如果负载因子越大,对空间的利用更充分,然而后果是查找效率的降低;如果负载因子太小,那么散列表的数据将过于稀疏,对空间造成严重浪费。

HashMap的实现中,通过threshold字段来判断HashMap的最大容量:

threshold = (int)(capacity * loadFactor);

结合负载因子的定义公式可知,threshold就是在此loadFactor和capacity对应下允许的最大元素数目,超过这个数目就重新resize,以降低实际的负载因子。默认的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时, resize后的HashMap容量是容量的两倍:

 

7. HashMap 的工作原理是什么?

一,存储方式:  Java中的HashMap是以键值对(key-value)的形式存储元素的。

二,调用原理: HashMap需要一个hash函数,它使用hashCode()和equals()方法来向集合/从集合添加和检索元素。当调用put()方法的时候,HashMap会计算key的hash值,然后把键值对存储在集合中合适的索引上。如果key已经存在了,value会被更新成新值。

HashMap的实现原理:

1. 利用key的hashCode重新hash计算出当前对象的元素在数组中的下标

2. 存储时,如果出现hash值相同的key,此时有两种情况。(1)如果key相同,则覆盖原始值;(2)如果key不同(出现冲突),则将当前的key-value放入链表中

3. 获取时,直接找到hash值对应的下标,在进一步判断key是否相同,从而找到对应值。

4. 理解了以上过程就不难明白HashMap是如何解决hash冲突的问题,核心就是使用了数组的存储方式,然后将冲突的key的对象放入链表中,一旦发现冲突就在链表中做进一步的对比。


纯属个人总结,如有不对的,欢迎指出!感谢诸君的支持,点个赞吧!


打开App,阅读手记
6人推荐
发表评论
随时随地看视频慕课网APP