HashMap面试

你的朋友圈y

已于 2023-01-06 11:13:08 修改

阅读量116

点赞数

分类专栏：八股文面试文章标签：数据结构哈希算法散列表

于 2023-01-02 18:29:06 首次发布

本文链接：https://blog.csdn.net/m0_59805036/article/details/128523230

版权

八股文面试专栏收录该内容

4 篇文章 0 订阅

订阅专栏

⼩伙⼦你了解数据结构中的HashMap么？能跟我聊聊他的结构和底层原理么？

HashMap是我们非常常用的一种数据结构，由链表和数组组合构成的数据结构。

⼤概如下，数组⾥⾯每个地⽅都存了Key-Value这样的实例，在Java7叫Entry在Java8中叫Node。

因为它最初所有的位置都为null，在put插入数据时会根据key的hash去计算一个index值。

例如：

比如说我put("余温",520)，我插入一个"余温的元素"，这个时候我们会通过hash函数计算出插入的位置，计算出index是2，因此结果如下。

hash("余温") = 2

你提到了还有链表，为啥需要链表，链表⼜是怎么样⼦的呢？

我们都知道数组⻓度是有限的，在有限的⻓度⾥⾯我们使⽤哈希，哈希本身就存在概率性，就是"余温"和"温余"我们都去hash有⼀定的概率会⼀样，就像上⾯的情况我再次哈希"温余"极端情况也会hash到⼀个值上，那就形成了链表。

每个节点都会保存自身的hash、key、value、以及下一个节点，我们看一下Node的源码

    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

说到链表我想问⼀下，你知道新的Entry节点在插⼊链表的时候，是怎么插⼊的么？

java8之前是头插法，意思就是新来的值会取代原有的值，原有的值就顺推到链表中去，就像上面的例子，因为当时写代码的这个作者认为后来的值被查找的可能性更大，提升查找的效率。

但是，在java8之后，都使用尾部插入了。

>•  为啥改为尾部插入呢？

有⼈认为是作者随性⽽为，没啥luan⽤，其实不然，其中暗藏⽞机

首先我们看下HashMap的扩容机制:

由于数组容量是有限的，数据多次插入的，到达一定的数量就会进行扩容，也就是resize。

什么时候resize呢？

有两个因素：

Capacity：HashMap当前长度
LoadFactor：负载因子，默认值0.75f。

怎么理解呢，就比如当前的容量大小为100，当你存进第76个的时候，判断发现需要进行resize了，那就进行扩容，但是HashMap的扩容也不是简单的扩大点容量这么简单的.

扩容？它是怎么进行扩容的呢？

分为两步

扩容：创建一个新的Entry空数组，长度是原数组的两倍。
ReHash：遍历原Entry数组，把所有的Entry重新Hash到新的数组。

为什么要重新Hash呢，直接复制过去不行吗？

是因为长度扩大之后，Hash的规则也会随之改变。

Hash的公式---> index = HashCode（Key） & （Length - 1）原来⻓度（Length）是8你位运算出来的值是2 ，新的⻓度是16你位运算出来的值明显不⼀样了。

扩容前：

扩容后：

说完扩容机制我们⾔归正传，为啥之前⽤头插法，java8之后改成尾插了呢？

先来举个例子吧，比如说我们现在向一个容量大小为2的里面put两个值，负载因⼦是0.75是不是我们在put第⼆个的时候就会进⾏resize？

2 * 0.75 = 1 所以我们在插入第二个的时候就要resize了。

现在我们要在容量为2的容器⾥⾯⽤不同线程插⼊A，B，C，假如我们在resize之前打个短点，那意味着数据都插⼊了但是还没resize那扩容前可能是这样的。我们可以看到链表的指向A->B->C

Tip：A的下⼀个指针是指向B的

因为resize的赋值⽅式，也就是使⽤了单链表的头插⼊⽅式，同⼀位置上新元素总会被放在链表的头部位置，在旧数组中同⼀条Entry链上的元素，通过重新计算索引位置后，有可能被放到了新数组的不同位置上。

就可能出现下⾯的情况，B的下⼀个指针指向了A

⼀旦⼏个线程都调整完成，就可能出现环形链表

如果这个时候去取值，悲剧就出现了——Infinite Loop。

头插是JDK1.7的那1.8的尾插是怎么样的呢？

因为java8之后链表有红⿊树的部分，⼤家可以看到代码已经多了很多if else的逻辑判断了，红⿊树的引⼊巧妙的将原本O(n)的时间复杂度降低到了O(logn)。 Tip：在这⾥过多描述了，之后专门出一篇关于红黑树的。

使⽤头插会改变链表的上的顺序，但是如果使⽤尾插，在扩容时会保持链表元素原本的顺序，就不会出现链表成环的问题了。就是说原本是A->B，在扩容后那个链表还是A->B，如下图所示。

Java7在多线程操作HashMap时可能引起死循环，原因是扩容转移后前后链表顺序倒置，在转移过程中修改了原来链表中节点的引⽤关系。

Java8在同样的前提下并不会引起死循环，原因是扩容转移后前后链表顺序不变，保持之前节点的引⽤关系。

那是不是意味着Java8就可以把HashMap⽤在多线程中呢？

我认为即使不会出现死循环，但是通过源码看到put/get⽅法都没有加同步锁，多线程情况最容易出现的就是：⽆法保证上⼀秒put的值，下⼀秒get的时候还是原值，所以线程安全还是⽆法保证。

那我问你HashMap的默认初始化⻓度是多少？

我记得我在看源码的时候初始化⼤⼩是16

那你知道为什么是16么？

编辑器会提醒我们最好赋初值，而且最好是2的幂，这样为了位运算方便，位运算比算数计算的效率高很多，之所以选择16是为了服务将key映射到index的算法中；上面讲到了put的时候会hash一些key的值，但是我们怎么尽最大可能得到一个均匀分布的hash呢？我们通过的是key的hashcode值去做位运算。例如： key为上面的"余温"十进制为873775二进制为11010101010100101111 HashMap下标的计算方式是index=HashCode（Key）&（Length-1）代入得 11010101010100101111&1111 十进制就是15

之所以⽤位与运算效果与取模⼀样，性能也提⾼了不少！

那为啥⽤16不⽤别的呢？

因为在使⽤不是2的幂的数字的时候，Length-1的值是所有⼆进制位全为1，这种情况下，index的结果等同于HashCode后⼏位的值。

只要输⼊的HashCode本身分布均匀，Hash算法的结果就是均匀的。

这是为了实现均匀分布。

那我问你个问题，为啥我们重写equals⽅法的时候需要重写hashCode⽅法呢？

你能⽤HashMap给我举个例⼦么？

因为在java中，所有的对象都是继承于Object类。Ojbect类中有两个⽅法equals、hashCode，这两个⽅法都是⽤来⽐较两个对象是否相等的。

对于值对象，==⽐较的是两个对象的值
对于引⽤对象，⽐较的是两个对象的地址

在未重写equals⽅法我们是继承了object的equals⽅法，那⾥的 equals是⽐较两个对象的内存地址，显然我们new了2个对象内存地址肯定不⼀样

⼤家是否还记得我说的HashMap是通过key的hashCode去寻找index的，那index⼀样就形成链表了，也就是说"余温"和"温余"的index都可能是2，在⼀个链表上的。

我们去get的时候，他就是根据key去hash然后计算出index，找到了2，那我怎么找到具体的"余温"还是"温余"呢？

equals！是的，所以如果我们对equals⽅法进⾏了重写，建议⼀定要对hashCode⽅法重写，以保证相同的对象返回相同的hash值，不同的对象返回不同的hash值。

不然⼀个链表的对象，你哪⾥知道你要找的是哪个，到时候发现hashCode都⼀样，这不是完犊⼦嘛。

可以可以⼩伙⼦，我记得你上⾯说过他是线程不安全的，那你能跟我聊聊你们是怎么处理HashMap在线程安全的场景么？

⾯试官，在这样的场景，我们⼀般都会使⽤HashTable或者ConcurrentHashMap，但是因为前者的并发度的原因基本上没啥使⽤场景了，所以存在线程不安全的场景我们都使⽤的是ConcurrentHashMap。 HashTable我看过他的源码，很简单粗暴，直接在⽅法上锁，并发度很低，最多同时允许⼀个线程访问，ConcurrentHashMap就好很多了，1.7和1.8有较⼤的不同，不过并发度都⽐前者好太多了。