Java中HashMap的实现原理

最新推荐文章于 2023-02-13 00:23:26 发布

everxs

最新推荐文章于 2023-02-13 00:23:26 发布

阅读量265

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/everxs/article/details/81416831

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

最近公司解散了，找工作期间无聊，写写博客。解读一下jdk1.8中HashMap的源码。如有解析不对，欢迎评论指教

作者：郑嘉裕

微信：vn1906(欢迎博客好友共同探讨技术问题)

HashMap设计思路：

1、简单分析数组跟链表：先从数组跟链表讲起吧，数组的遍历为什么快？链表的遍历为什么慢？这里就再解释一下，因为数组是基于下标查询的，比如int a[] = {1，2，3，4，5}，你要查找第三个元素，可以直接 a[2],是可以直接拿到值的，因为数组是连续的内存空间，int又是固定的空间，所以找第几个的时候，可以直接通过偏移获取到，不懂得可以去看下c中的指针，可以让你更好理解。但是链表呢，因为是不连续的内存空间地址，你要拿第三个，需要去找到表头，再通过next找到第二个，再next找到第三个。所以找第几个元素的时候，链表需要遍历。所以链表的性能就比较差。这里就不对比数组跟链表了。

2、HashMap的存储结构：基于数组的特性，我们可以进行下面的思考

假设 HashMap<key,value>,以key的hashcode为数组的下标可不可以呢？理想肯定是好的，但是现实嘛，肯定会做一下修改。在不重写hashcode的情况下，比如 Integer的hash是本身。大家知道数组是需要预先创建的，如果你一开始put进map的值是999999，那hashmap的中对于key这个数组大小岂不是需要999999？显然不合理。所以对于这个实现，hashmap做了优化，那就是取模，比如 key作为寻址，数组初始化长度是10，那999999取完模也就是9而已。这样就显得比较合理了。那比如 99跟9都对10取模，那岂不是都落到下标为9的位置？那怎么存储呢？答案是，在9这个位置存一个链表。大家都知道，链表是不连续的，所以链表理论上是可以无限大的。所以hashmap的存储结构我们暂时可以理解为数组加链表如图，用数组长度为10，key元素分别为99，9，8，7的存储位置。

99%10=9；

9%10=9；

8%10=8；

7%10=7；

数组	0	1	2	3	4	5	6	7	8	9
链表	表0	表1	表2	表3	表4	表5	表6	表7	表8	表9
								7	8	9
										99

看完大家也就知道了大概的思路了，就是数组里面的元素放着一个链表

最理想的存储结构是怎样呢？那就是10个数据都落在不一样的下标，切只有一个元素。也就是说，每个数组的位置都是一个节点。这样的效率是最高的，就比如我们之前讲的，用数组的下标去取值那样a[key.hashCode] ,这样又快又直接。但是现实肯定是不丰满。最主要是不可能一下子创建这么大的数组，所以数组里的元素存放一个链表。。

3、HashMap的查找

既然存储结构我们知道了，那如上面的存储表，找一个key为9的值，那我们就先取模，定位到a[9]，然后遍历该链表，直到找到key为9的Node。讲到这里大家也就应该直到为什么HashMap中的key不能重复的原因了吧。

4、HashMap的hash()方法

按照我们之前的思路，我们大概有了头绪，只是人家HashMap又做了一点优化，那就是对于key的hashcode又再做了一次hash处理。先贴一下源码

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

代码的意思是什么呢？就是右移16位，再做一次异或。

复习一下 ^(异或)
0^0=0;
1^1=0;
0^1=1;
1^0=1

原	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	0	0	1	1	1	1	1	0	0	0	1	1	0	1	1	1
>>>16	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1
^	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	1	0	0	0	0	0	1	1	1	0	0	1	0	0	0

这段代码的意思大概就是：混合原始哈希码的高位跟低位，以此来加大低位的随机性。为什么要这样子呢？理解不了我觉得也无所谓，你就先按你的理解就当做它没做这个处理吧。

5、HashMap的初始化数组长度

现在我们来看看hashmap的初始化。


    /**
     * The default initial capacity - MUST be a power of two.
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

这个表示，初始化的时候数组长度为16（有些人叫桶），这里分析一下。为什么是16，而不是15，14 ，13？

首先人家告诉你的是，必须是2的平方倍。16=2^4；

接下来我们就来分析为什么是 16（2的平方倍）

很简单，先看看他怎么存一个数据的，源码看不懂不要管。略过

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;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            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))))
                e = p;
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            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;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

我们分析重点的就好了，代码只是贴出来看看，里面的table是上面定义的table，看下表的代码。大概你们可以猜出来就是我们前面分析的数组。

transient Node<K,V>[] table;

在分析一下 put的操作，n=tab.length 也就是说 n是我们上面所说的数组长度，

(n-1)&hash 这里大家可以看到。这个跟我们上面所说的原理差不多，但是它进行的是一个&操作。下面我们来分析一下这个算法

Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {

首先，我们来看看，n-1的情况。拿16来说也就是2^4。

假设一个值得hash是9

15（n-1）	1	1	1	1
9	1	0	1	0
结果	1	0	1	0

&的操作是，都是1，结果才是1

如果是0-14的数。基本上就全部散列在我们所期望的数组下面的。不会出现重复，我们来看这样一个情况.如果是n-2也就是n=15

14(n-1)	1	1	1
9	1	0	1
结果	1	0	1

这样对比起来似乎没什么关系，但是仔细看最后一位。那就是位数是1跟0做了&运算之后都为0了。这样就出现什么情况呢

14(n-1)	1	1	1	0
9	1	0	1	0
10	1	0	1	1
结果	1	0	1	0

这时候大家应该可以发现。9跟10位置一样。这样就不够散列稀疏了。有人问那如果长度 n=16,那9跟24的下标也一样啊。这是两个维度。也就是下面会讲的HashMap的扩容

讲到这里大家已经知道了，为什么HashMap的桶（数组）为2的倍数了,那就是 1111111111111111。都要是1

6、HashMap的扩容原理

6.1这里先来讲一下，为什么要扩容？

按照我们之前讲的数据结构，HashMap的存储，大家应该知道查找是怎样了吧。就是先hash,再进行&运算获得数组下标。再遍历链表。如果能理解到这里，我觉得你已经大概了解hashmap了。这里有个重点。就是如果数组长度永远是16，如果数据量很大的时候，就会出现hash冲突，也就是说。不同的数落在了同一个桶（数组下标），如果数据量巨大的时候。那么桶里面的数据也非常大，按照之前讲的。桶里面是一个链表，那就说明还是需要遍历。当链表很大的时候，那遍历速度就慢了。这个情况之前已经见过了，不再累赘。所以hashmap就需要扩容，好让它可以达到我们之前讲的，最好是一个桶一个元素。

6.2什么时候扩容？



//这里定义为一个阈值，就是HashMap中数据的个数。
threshold=capacity*loadFactor
capacity//桶的数量也就是我们之前说的数组
loadFactor//装载因子，默认是0.75

当进行put的时候，hashmap里面的元素大于threshold（阈值），这个时候就进行扩容

6.3怎么扩容？

这个问题我说了不算，源码说了算，我们继续看源码，代码很多，大家不想看就忽略吧

final Node<K,V>[] resize() {
        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; 
        }
        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;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    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;
                        }
                    }
                }
            }
        }
        return newTab;
    }

扩容就是一倍，为什么是一倍。上面讲解为什么是16的时候已经见过了。2的N次方。由于阈值是int类型，所以到了int的最大值就不扩容了。

7、总结

大概已经讲了hashmap的原理，如果想更深入的理解，建议看看源码，如果有讲得不对可以指出

面试的时候人家问到的时候，总结一下几点

1、hashmap的结构是数组加链表，或者说桶里面放着一个链表

2、初始化长度为16，桶的数量为2N次方，因为 &运算是跟桶数-1进行操作的。为了保证每个位都是1，实现离散

3、当hashmap里面元素的数量>桶*加载因子的时候，实现扩容。加载因子默认是0.75

4、扩容后的长度为原来的一倍。

5、使用hashmap的时候，如果预知数量比较大。可以初始化一个值。根据加载因子去推算。不然会hash冲突，导致一直扩容。

6、源码里操作都没有同步或者加锁，所以hashmap是线程不安全的。

everxs

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中HashMap的实现原理

最近公司解散了，找工作期间无聊，写写博客。解读一下jdk1.8中HashMap的源码。如有解析不对，欢迎评论指教作者：郑嘉裕微信：vn1906(欢迎博客好友共同探讨技术问题)HashMap设计思路：1、简单分析数组跟链表：先从数组跟链表讲起吧，数组的遍历为什么快？链表的遍历为什么慢？这里就再解释一下，因为数组是基于下标查询的，比如int a[] = {1，2，3，4，5}，你要...
复制链接

扫一扫