HashMap常见问题

已于 2023-02-21 21:24:28 修改
阅读量937 收藏 1
点赞数 1
分类专栏： JDK 文章标签： java 散列表 哈希算法 hashmap
于 2022-01-14 14:18:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38277138/article/details/122492995
版权

1.HashMap与HashTable

相同点

HashMap和HashMap都是基于哈希表实现的，其内部的每个元素都是key-value键值对，HashMap和HashTable都实现了Map、Cloneable、Serializable接口

不同点

  • 父类不同：HashMap继承了AbstracMap类，而HashTable继承了Dictinart类
    在这里插入图片描述

  • 空值不同：HashMap允许空的key和value值，HashTable不允许空的key和value
    在这里插入图片描述

  • 线程安全性：HashMap线程不安全，HashTable安全

  • 性能：虽然都是基于单链表，但是由于HashTable的put、get、remove操作加了synchronized锁，所以效率低在这里插入图片描述

  • 初始容量：

    HashTable初始长度11，每次扩容变为2n+1
    HashMap初始容量16，每次扩充变为原来的两倍
    创建给定初始容量时，HahsTable会直接使用给定大小，HashMap扩充到2的幂次方

2.HashMap与HashSet

  • HashSet集成了AbstractSet接口，实现了Set、cloneable、Serializable接口
  • HashSet不允许出现重复的值
  • HashSet底层就是HashMap，所有对HashSet的操作其实就是对HashMap的操作，不保证顺序
    在这里插入图片描述

3.HashMap结构图

在这里插入图片描述

4.AbstractMap类

  • Map接口的骨干实现
  • 集成这个类并且提供entrySet方法即可返回不可修改的map
  • 为了实现可修改，必须额外重写put()方法，并且entrySet.iterator必须实现remove()方法

5.Node接口

Node节点是用来存储HashMap的一个个实例，它实现了Map.Entry接口，我们先来看一下Map中的内部接口Entry接口的定义

6.Map.Entry

一个map的entry链，是这个Map.entrySet()返回的一个集合视图，包含了各种的元素
这个唯一的方式是从集合的视图进行迭代，获取一个map的entry链，这个Map.Entry链只在迭代期间有效
Node节点会存储四个属性，hash值，key，value，指向下一个Node节点的引用
因为Map.Entry是一条条entry链连接在一起的，所以Node节点也是一条条entry链

7.KeySet内部类

继承于AbstractSet抽象类，它是由HashMap中的keyset()方法来创建KeySet实例的，旨在对HashMap中的key键进行操作

    /**
   *  返回一个set视图，这个视图中包含了map中的key
   **/
    public Set<K> keySet() {
        // keySet 指向的是 AbstractMap 中的 keyset
        Set<K> ks = keySet;
        // 如果 ks 为空，就创建一个 KeySet 对象
        if (ks == null) {
            // 并对 ks 赋值
            ks = new KeySet();
            keySet = ks;
        }
        return ks;
    }

8.values内部类

和keyset类似，只是针对key-value键值对中的value值进行使用

9.EntrySet内部类

对key-value键值对进行操作的内部类

10.HashMap1.7底层结构

JDK1.7中，HashMap采用位桶+链表的实现，即使用链表来处理冲突，同一hash值的链表都存储在一个数组中。但是当未育一个桶中的元素较多，即hash值相等的元素较多时，通过key值以此查找的效率较低
HashMap大致结构
HashMap底层数据就是一个Entry数组，Entry是HashMap的基本组成单元，每个Entry中包含一个key-value键值对，每个Entry包含 【hash，key，value】 属性，如图：
在这里插入图片描述

11.HahsMap1.8底层结构

与JDK1.7相比，1.8在底层结构方便做了一些改变，当每个桶中元素大于8的时候，会转变为红黑树，目的就是优化查询效率，JDK1.8重写了resize()方法
在这里插入图片描述

12.HashMap重要属性

初始容量

HashMap的默认容量为： 16

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

在这里插入图片描述

最大容量

HashMap最大容量为： 2^30

static final int MAXIMUM_CAPACITY = 1 << 30;

Q？int占用4个字节，按说最大容量应该是左移31位
A：数值计算中，最高位也就是最左边的位数为符号位，代表正负，0->正数，1->负数

默认负载因子

HashMap默认负载因子为：0.75f

static final float DEFAULT_LOAD_FACTOR = 0.75f;

扩容机制的原则是当HashMap中存储的数量>HashMap容量*负载因子时，就会把HashMap的容量扩大为原来的两倍。

HashMap的第一次扩容就是在 16*0.75=12 时进行
树化阈值

HashMap的树化阈值为：8

static final float DEFAULT_LOAD_FACTOR = 0.75f;

在添加元素时，当一个桶中存储元素的数量>8时，会自动转化成红黑树

链表阈值

HashMap的链表阈值为：6

static final int UNTREEIFY_THRESHOLD = 6;

在进行删除元素时，如果一个桶中存储元素数量<6之后，会自动跳转为链表

扩容临界值

64

static final int MIN_TREEIFY_CAPACITY = 64;

这个值表示的是当桶数组容量小于该值时，优先进行扩容，而不是树化

节点数组

HashMap中的节点数组就是Entry数组，它代表的就是HashMap中 【数组 + 链表】 数据结构中的 数组
Node数组在第一次使用的时候进行初始化操作，在必要的时候进行resize，resize后的数组的长度扩容为原来的二倍

键值对数量

在HashMap中，使用 size 来表示HashMap中键值对的数量

修改数量

在HashMap中，使用modCount来表示修改次数，主要用于做并发修改HashMap时的快速失败，即：

-fail-fast机制
扩容阈值

在HashMap中，使用 threshold 表示扩容的阈值，也就是 初始容量*负载因子的值
这个问题由 tableSizeFor() 源码解决的

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

在这里插入图片描述

负载因子

loadFactory表示负载因子，它表示的是HashMap的密集程度

13.HashMap put全过程

  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)//首次初始化的时候table为null
            n = (tab = resize()).length;//对HashMap进行扩容
        if ((p = tab[i = (n - 1) & hash]) == null)//根据hash值来确认存放的位置。如果当前位置是空直接添加到table中 PS: 多线程情况下可能出现值覆盖
            tab[i] = newNode(hash, key, value, null);
        else { //如果存放的位置已经有值
            Node<K, V> e;
            K k;
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))//如果插入位置key重复
                e = p;
            else if (p instanceof TreeNode)//如果插入的位置正好是红黑树
                e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);//将数据put到红黑树
            else {//如果以上条件均不满足  就说明还是链表
                for (int binCount = 0; ; ++binCount) {//遍历链表
                    if ((e = p.next) == null) { //遍历到链表的尾节点
                        p.next = newNode(hash, key, value, null); //新建一个链表节点(可以看出HashMap链表是尾插的)
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st 判断链表长度是否大于8(binCount是从0开始)
                            treeifyBin(tab, hash);//如果循环了达到了红黑树的阈值，也就是说这里的链表长度大于8，然后就把这个结构树形化。
                        break;
                    }
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;//在循环的过程中遇到了key值相同的节点，跳出循环
                    p = e;//和前面for中的p.next对应，进行循环遍历链表。
                }
            }
            if (e != null) { // existing mapping for key   如果e!=null  说明存在相同的key
                V oldValue = e.value;//记录下原来的key对应的value
                if (!onlyIfAbsent || oldValue == null)//当onlyIfAbsent为false或者旧值为空
                    e.value = value;//替换新的value并返回旧的value
                afterNodeAccess(e);//HashMap中暂无实现
                return oldValue;//返回旧值，这样就处理掉了前面的当key值相同时的情况了。
            }
        }
        ++modCount;// 每次容器发生变化记录
        if (++size > threshold)// 实际大小大于阈值则扩容
            resize();//如果当前HashMap的容量超过threshold则进行扩容
        afterNodeInsertion(evict);//HashMap中暂无实现
        return null;
    }

    final void treeifyBin(Node<K, V>[] tab, int hash) {
        int n, index;
        Node<K, V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K, V> hd = null, tl = null;
            do {
                TreeNode<K, V> p = replacementTreeNode(e, null);//将Node节点变换为TreeNode节点
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);//转换成双向链表
            if ((tab[index] = hd) != null)
                hd.treeify(tab);//将链表树化
        }
    }

在这里插入图片描述

扩容机制

14.时间复杂度

当桶中无元素 ->O(1)
当桶中元素为链表时 -> O(1)+O(n)
当桶中元素为红黑树时 -> O(1)+O(logn)

15.如何处理hash碰撞

HashMap底层是使用桶+链表实现的，位桶决定元素的插入位置，位桶是有hash方法决定的，当多个元素的hash计算得到相同的哈希值后，HashMa会把多个Node元素都放在对应的位桶中个，形成链表，这种处理哈希碰撞的方式被称为链地址法

16.HashMap如何get元素

首先会检查 table 中的元素是否为空，然后根据 hash 算出指定 key 的位置。然后检查链表的第一个元素是否为空，如果不为空，是否匹配，如果匹配，直接返回这条记录；如果匹配，再判断下一个元素的值是否为 null，为空直接返回，如果不为空，再判断是否是 TreeNode 实例，如果是 TreeNode 实例，则直接使用 TreeNode.getTreeNode 取出元素，否则执行循环，直到下一个元素为 null 位置。

17.HashMap如何扩容

HashMap 中有两个非常重要的变量，一个是 loadFactor ，一个是 threshold ，loadFactor 表示的就是负载因子，threshold 表示的是下一次要扩容的阈值，当 threshold = loadFactor * 数组长度时，数组长度扩大位原来的两倍，来重新调整 map 的大小，并将原来的对象放入新的 bucket 数组中。

18.数组大小为什么是2的幂次方

查找数组对应的位置需要通过取余计算，HashMap源码中是通过位运算计算数据下标：

int index = hash & (length - 1)

主要是通过key的hash值与数组长度减一做与运算，而要满足于取余预算结果相等的条件，数组长度只能为2的幂次方。

为什么是length-1而不是length

由于length-1一定是基数，因此二进制最后一位永远为1，又是因为与运算，因此最终结果可能为0也可能为1，尽可能的保证分布的松散型，减少hash碰撞

19.HashMap算法

扰动函数

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

在这里插入图片描述

右移16位，正好是32bit的一半，自己的高半区和低半区做异或，就是为了混合原始哈希码的高位和低位，以此来加大低位的随机性，而且混合后的地位掺杂了高位的部分特征，这样高位的信息也被变相的保留下来

20.为什么要延迟初始化

new HashMap()的时候只是进行参数传递，真正初始化是在put元素的时候执行resize()
目的：性能优化，节约堆内存

21.树化阈值为什么是8

关键词：泊松分布

LinkedList转化成红黑树非常消耗性能，要尽可能避免
同样我们也希望数据直接落在table中，尽可能少形成链表或者长链表，因此根据泊松分布计算得出（概率学），链表长度达到8的概率已经是极低了，根据源码注释可知，HashMap桶中90%都是0-1长度的链表，性能很高

     /** threshold of 0.75, although with a large variance because of
     * resizing granularity. Ignoring variance, the expected
     * occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
     * factorial(k)). The first values are:
     *
     * 0:    0.60653066
     * 1:    0.30326533
     * 2:    0.07581633
     * 3:    0.01263606
     * 4:    0.00157952
     * 5:    0.00015795
     * 6:    0.00001316
     * 7:    0.00000094
     * 8:    0.00000006
     * more: less than 1 in ten million
     **/

22.JDK1.8为什么要使用红黑树

历史：JDK7时存在一个bug，Apache Tomcat使用哈希表存储HTTP请求参数时，由于哈希表冲突引发Dos漏洞（服务器仍在运转却拒绝用户访问）
解决方法：主要是因为hash冲突导致链表过长，因此在JDK1.8中引入了红黑树，减少因为链表过长导致的查询速度过慢问题
补充：Tomcat在JDK1.8发布之前采用了一个伤害不大，侮辱性极强的解决方案，引入参数限制处理的参数数量，默认10000

23.HashMap什么情况下会造成死循环

  • 多线程扩容机制导致的，形成了循环链表
  • JDK7中采用了头插法更容易引发
  • JDK8引入红黑树只是解决性能问题，不影响死循环问题

简要描述：扩容会执行链表循环，当Node.next() == null时，跳出循环，多线程会打乱这段逻辑

24.JDK1.7为什么使用头插法

符合优先使用最近的数据原则，新插入的更有可能被用到

25.为什么选择红黑树

HashMap是综合效率最高的数据结构，因此也需要选择综合效率最高的红黑树
平衡二叉树付出很大的代价形成结构，因此采用红黑

26.HashTable

数据结构基本与HashMap相似，只是对map操作的方法都加上了synchronized关键字，全表锁，性能很低

27.ConcurrentHashMap

JDK1.7

分段锁，默认16个分段锁

JDK1.8

引入cas操作：put元素至数组时，采用cas无锁操作，判断链表是否为空
引入synchroized关键字锁住node节点本身

28.什么是ConcurrentHashMap的弱一致性

有可能脏读，读出数据并非实时

哦灬吼吼吼
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HashMap常见面试题，简述以及对源码操作分析
01-28
HashMap常见面试题，简述以及对源码操作分析
HashMap实现原理及扩容机制
HenryPoP的博客
05-20 500
HashMap实现原理及扩容机制HashMap基础HashMap基础HashMap实现原理Node和Node链拉链法关于Node数组 table散列算法HashMap和红黑树关于TreeNode红黑树基础HashMap扩容机制JDK1.7下的扩容机制JDK1.8下的扩容机制 参考：添加链接描述 HashMap基础 HashMap继承了AbstractMap类，实现了Map，Cloneable，Serializable接口 HashMap基础 HashMap的容量，默认是16 /** * T
HaMap源码阅读（put()方法流程图）
yeyeyhehe的博客
10-10 609
@TOC public V put(K key, V value) { return putVal(hash(key), key, value, false, true); } /** * Implements Map.put and related methods * * @param hash hash for key * @param key the key * @param value the value to pu
hashtable的结构和扩容机制
pige666的博客
02-20 1713
最外层封装了dictht，结构如下table指向了实际存储的hash结构dictEntry。size是哈希表大小，也就是说dictEntry有多少空间。sizemask是掩码，为固定值size-1，然后元素的index就应该是元素哈希值&sizemask。used代表dictEntry里面多少个坑位已经被用上了。假设index冲突了，用拉链法（头插，避免尾插法遍历到尾巴这一O(n)的时间开销）解决。
Java HashMap中在resize()时候的rehash,即再哈希法的理解
热门推荐
请叫我大师兄
08-22 2万+
HashMap的扩容机制---resize() 扩容(resize)就是重新计算容量，向HashMap对象里不停的添加元素，而HashMap对象内部的数组无法装载更多的元素时，对象就需要扩大数组的长度，以便能装入更多的元素。当然Java里的数组是无法自动扩容的，方法是使用一个新的数组代替已有的容量小的数组，就像我们用一个小桶装水，如果想装更多的水，就得换大水桶。 我们分析下resi
【聊聊Java】Java中HashMap常见问题 -- 扩容、树化、死链问题
BASK2312的博客
11-04 580
其实一般正常的元素，都是不会超过阈值的，只有插入一堆重复的元素，hash值一样，才可能达到阈值，这个简称Dos攻击 而元素一旦多起来，链表查找的效率就远不及红黑树了。因为HashMap的初始容量是2的次幂，扩容之后的长度是原来的二倍，新的容量也是2的次幂，所以，元素，要么在原位置，要么在原位置。不是的，维护红黑树需要占用比链表更多的空间，而且当链表长度足够短的时候，链表查找的效率反而比红黑树更高？可以的，因为2的n次方也会有缺陷，比如给定的值全是偶数，无论如何hash之后取模，都是偶数，分布就不均匀。
jdk-HashMap-1.8
lwgzj的博客
07-11 206
由于jdk版本的升级导致源码的更新，因此hashmap的源码需要重新读一下，不过在本文记录时jdk的版本早就不是8版本了，只不过是1.7和1.8发生了本质的变化，因此才记录一下的。至于9,10版本，暂时不管了。为了重新去读1.8版本的hashmap源码，特此做了些前期准备：红黑树系列jdk1.7jdk1.7补充文章1.总述关于之前学习的1.7版本，我着重学习了几个点，构造函数（容量大小，加载因子）...
 9.为什么hashtable的扩容是2倍+1    
qq_39922867的博客
03-14 3161
9.为什么hashtable的扩容是2倍+1 protected void rehash() { int oldCapacity = table.length;//旧容量 Entry<K,V>[] oldMap = table;//旧的桶数组 // overflow-conscious code ...
哈希表相关知识
wwzzzzzzzzzzzzz的博客
07-17 1484
哈希冲突如果两个对象通过相同的哈希函数计算出相同的HashCode相同,这种现象称为hash冲突.①开放定址法当发生哈希冲突时,如果哈希表未被装满,说明在哈希表中必然还有空位置,那么可以把把key存放到冲突位置的"下一个位置"去②链地址法对于相同的值,使用链表进行链接.使用数组存在每一个链表.③再hash法通过某个hash函数计算的key存在冲突的时候,再用另外的hash函数对这个key做hash,一致运算直到不再产生冲突.④建立公共溢出区。......
互联网公司问题总结1
weixin_43185348的博客
10-25 538
1.synchrnoized和reentrantlock的底层实现及重入的底层原理 monitorenter monitorexit AQS。 重入原理：entry count，state 2.锁的四种状态及升级过程 3.CMS和G1的异同 4.G1什么时候引发Full GC 5.除了CAS，原子类，syn，Lock还有什么线程安全的方式 final 6.HashMap和Hashtable的异同 7.允许null键的map你知道哪些 HashMap，LinkedHashMap，WeakHashMap 8.n
一文带你深入理解Hashtable
weixin_49307478的博客
09-14 812
HashTable底层的实现机制是什么？HashTable的扩容机制是什么？HashTable和HashMap的区别是什么？存储key-value键值对格式是无序的底层通过数组+链表的方式实现通过synchronized关键字实现线程安全key、value都不可以为null（为null时将抛出NullPointerException）实现了Map接口，提供了键值对增删改查等基础操作继承了Dictionary字典类，Dictionary是声明了操作"键值对"函数接口的抽象类。
07-HashMap常见面试题分析.mp4
05-11
07-HashMap常见面试题分析.mp4
面试题之详解HashMap
12-21
本文着重介绍关于Hashmap的常见面试题，读者需对HashMap有基本的了解 文章目录1.HashMap长度为什么是2的幂次方2.HashMap多线程操作导致死循环问题3.HashMap的底层实现4.扩容机制 1.HashMap长度为什么是2的幂次方 ...
HashMap和HashTable底层原理以及常见面试题
08-26
今天小编就为大家分享一篇关于HashMap和HashTable底层原理以及常见面试题，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
小白，和我一起学 HashMap 吗？
12-21
equals() 必须重写 hashCode()7、TODO：8、常见面试题9、鸣谢 1、前言 本文主要讲解HashMap的底层数据结构、存取原理、扩容机制、线程安全性、java 7 和java 8版本的对比等方面。如果你正在学习HashMap，希望对你有...
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 752
都是符合我们的预期的。
java方法重写（重点讲），方法重载
最新发布
weixin_46281068的博客
04-27 828
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
string模拟实现
m0_73969414的博客
04-23 1746
c++中string的模拟实现，面试必会知识点
HashMap的常见操作
07-28
回答: HashMap 是一种基于哈希表的 Map 接口实现，主要用来存放键值对。常见的 HashMap 操作包括插入、获取、删除和遍历。插入操作使用 put(key, value) 方法，将指定的键值对插入到 HashMap 中。获取操作使用 get(key) 方法，根据指定的键获取对应的值。删除操作使用 remove(key) 方法，根据指定的键删除对应的键值对。遍历操作可以使用 entrySet() 方法获取 HashMap 中的所有键值对，然后使用迭代器或者增强型 for 循环遍历每个键值对。需要注意的是，HashMap 不是线程安全的，如果在多线程环境下使用，需要进行额外的同步处理。\[1\]\[2\]\[3\] #### 引用[.reference_title] - *1* *2* *3* [HashMap详解](https://blog.csdn.net/java123456111/article/details/123378463)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^koosearch_v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值