HashMap数据结构剖析，看完这篇，面试它不再是拦路虎

最新推荐文章于 2023-05-30 15:39:04 发布

心存留恋就不会幸福

最新推荐文章于 2023-05-30 15:39:04 发布

阅读量442

点赞数

分类专栏： Coding_通用JAVA 文章标签：数据结构面试 hashmap

本文链接：https://blog.csdn.net/hachi_rt/article/details/122321877

版权

Coding_通用JAVA 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

引言：是否还在面试过程中被问到HashMap数据结构而被难住，来看看这篇吧！如有不足敬请斧正！

1.数据结构模型

数组 + 链表 + 红黑树（JDK 1.8引入）
初始化时为数组，插入时存在冲突，引入链表，链表查询慢引入红黑树。

2.JDK1.8引入红黑树只是为了效率吗？

不仅仅。HashMap会导致DOS攻击，可以搜索：线程安全的场景下；CVE-2011-4858;Tomcat邮件组的讨论时间。查看一种：没想到 Hash 冲突还能这么玩，你的服务中招了吗？ - 开发者头条。如果黑客在get后大量拼接hash冲突的键值对，tomcat键值存储时，形成链表，查询聊表效率低下，分分钟让CPU爆掉宕机！（扩展：服务器出现DOS，cpu 100%。kill -9不合适，重启不合适，别人依旧会再次攻击，top、jstack、jmap、atrhas命令，JVM性能调优，JVM性能排查，确定哪个线程，哪段代码有问题）

JDK8前为了避免上述问题，tomcat给参数长度设置了最大长度，JDK8后引入红黑树避免链表长度过长。

对于链表的查询效率，可以简单的使用：List<String> list = new ArrayList<>();List<String> list = new LinkedList<>();测试效率。

/***
 *  HashMap先比较hashcode,然后比较equals方法看是否是同一个对象。是就覆盖key的旧值，否则链表新插入。
 *  hashcode相同，且equals为true
 */
@Test
public void hashMap(){
    Map<String,String> hashMap = new HashMap<>();
    List<String> list = Arrays.asList("Aa","BB","C#");
    for(String s : list){
        //2112  2112   2112  哈希值相同，构成链表
        System.out.println(s.hashCode());
        hashMap.put(s,s);
    }
    for(String key : hashMap.keySet()){
        //Aa,Aa    BB,BB   C#,C#
        System.out.println(key + "," + hashMap.get(key));
    }
}

3.为什么是红黑树？

红黑树，属于二叉树，是二叉排序树，为什么不是平衡二叉树呢？树里面查询效率最高的是完全平衡的二叉树，但是比如10.11.12，11在10右边，12在11右边，这不是树，组成树树结构形式下那么10在11左下边，但是树的旋转也是十分消耗性能，红黑树尽量减少旋转属于折中方案，遵守最小长度min和最长长度:max <= 2min。

4.HashMap的哈希方法

Object的hashCode方法，调用了native本地(jvm实现，下载hotspot源码可查看)的hashCode(),
而HashMap定义了hash方法：

/***
 * HashMap的哈希方法
 * static final int hash(Object key) {
 *    int h;
 *    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 * }
 * 拆解：
 */
public int hash(Object key){
    int h;
    if(key == null){
        return 0;
    }else{
        h = key.hashCode();//哈希值,int 4个字节32位
        int temp = h>>>16; //右移16位
        int newHash = h ^ temp;  //异或运算(不同为1)
        return newHash;
    }
}

代码的拆解：

hash = hash(Object key)=hashCode^(hashCode>>>16)是为了什么？

查看源码，是为了计算下标，得到的值作为数组的定位，hash & (n-1)得到数组下标。

为啥hash & (n-1)这样计算可以作为数组下标？

一般计算下标的方法：hash%n取模，n为数组长度。但是这样需要多次运算，让得到的结果小于n。HashMap中对这种处理做了优化。

hash & (n-1)与hash%n为啥可以等效？

等效的前提是n为2的n次幂，HashMap的初始数组容量为16=2^4=10000,(n-1)=15=01111.
hash&(n-1)=hash&00000000000000000000000000001111,在与运算中，前28位无效，与之后的结果肯定是0，那么看低4位，所以hash&(n-1)的结果就是(0000,1111)=(0,15)正好是下标的取值范围。

为什么要右移16位？

让高位也参与运算，避免比较大的数据，高位不同，低位相同，那么下标都是低位计算，都是一样的。

为什么要用异或?

假如用&与，或者用非|，和异或^进行概率统计：

可以得出结论：HashMap的hash()算法是为了计算数组定位，避免hash冲突，使计算的数组下标更均匀，从而链表比较少，更高效。

5.数组的容量为什么是2的整数次幂？

h(k) = k mod m,除法散列发，在《算法导论》中，推荐我们m不应是2的整数幂，因为m=2^p，则h(k)就是k的p个最低位数字，除非我们已经知道各种最低P位的排列是等可能的，否则我们最好慎重的选择m，而一个不太接近2的整数幂的素数，往往是较好的选择。
因为在hash算法中已经使用了hash^(hash>>>16)优化，为了效率的同时，违背了算法导论。
在hashtable中，初始容量是11，遵循了算法导论。

6.扩容因子（元素的填充因子、加载因子）为什么是0.75？

扩容因子0.75就是元素占用率达到0.75，数组长度就扩容。
HashMap数组初始大小16，但是hash算法就是为了避免哈希冲突，不让产生大量的链表和红黑树。
扩容因子为1，空间利用率很高，但是意味填满了，很有可能有几个形成了链表，查询成本高，扩容因子为0.5利用率太低，综合考虑选取0.75。

7.HashMap树化参数为什么是8？

即链表大于等于8，转化成红黑树。
泊松分布：链表元素长度为7（7个元素出现哈希冲突）的概率是0.00000094，为8的概率是0.00000006，树化参数很小，转化红黑树资源消耗大。但是链表长度达到8，一定会树化吗？不是，源码里还有一个最小数化容量参数，值为64，就是要扩容到64，且长度大于等于8才会树化。

8.put方法详解

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;
    //tab为空时候，resize初始化或者扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
    //(n - 1) & hash 就是上面说的计算小标，判断下标有没有值
    if ((p = tab[i = (n - 1) & hash]) == null)
        //没有哈希冲突，直接存入
        tab[i] = newNode(hash, key, value, null);
    else {
        //哈希冲突
        Node<K,V> e; K k;
        //p是原有数组，特例：两个相同的key就会走这儿。
        if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
            //原来的值赋值给e
            e = p;
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            for (int binCount = 0; ; ++binCount) {
                //p后面没有值
                if ((e = p.next) == null) {
                    //p指向新的后面的节点
                    p.next = newNode(hash, key, value, null);
                    //判断是否需要要树化，判断长度是否大于等于8
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        //要判断数组长度是否大于64
                        treeifyBin(tab, hash);
                    break;
                }
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            //onlyIfAbsent 是false，旧值也不是null
            if (!onlyIfAbsent || oldValue == null)
                //新的value覆盖旧的value。
                e.value = value;
            afterNodeAccess(e);
            //hash冲突了，新的值覆盖旧的，且返回旧值。
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

9.扩容机制，扩容后数组怎么定位?

如上，哈希为4或者20，长度为16，取余( 或者上述的hash&(n-1) )数组下标都是4，扩容成32长度数组，则分别挂在4和20下标下-->扩容后的数组下标要么为原来位置，要么为原来位置+16。

为什么呢？
原hash&(16-1)更换为现在hash&(32-1)=hash&000000000000000000000000000011111，原来计算低四位，现在换成低5位，hash倒数低5位为1，则相当于原位置+10000即+16，为0则对结果没有影响就还是原位置。(扩容是为了让元素更分散）

10.为什么HashMap线程不安全？

多线程出现循环链表，尾指针指向上一个节点的头；
此时推荐使用ConcurrentHashMap；
为什么不用Map加锁？加锁让多线程变成了单线程，效率。concurrentHashMap没有用锁，CAS机制，原子操作。

完结！

心存留恋就不会幸福

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
HashMap数据结构剖析，看完这篇，面试它不再是拦路虎

引言：是否还在面试过程中被问到HashMap数据结构而被难住，来看看这篇吧！如有不足敬请斧正！1.数据结构模型数组 + 链表 + 红黑树（JDK 1.8引入）初始化时为数组，插入时存在冲突，引入链表，链表查询慢引入红黑树。2.JDK1.8引入红黑树只是为了效率吗？不仅仅。HashMap会导致DOS攻击，可以搜索：线程安全的场景下；CVE-2011-4858;Tomcat邮件组的讨论时间。查看一种：没想到 Hash 冲突还能这么玩，你的服务中招了吗？ - 开发者头条。如果黑客在ge.
复制链接

扫一扫