【简单了解系列】从基础的使用来深挖HashMap

HashMap定义

说的专业一点,HashMap是常用的用于存储key-value键值对数据的一个集合,底层是基于对Map的接口实现。每一个键值对又叫Entry,这些Entry分散的存储在一个由数组和链表组成的集合中。当然在Java8中,Entry变成了Node

说的通俗一点,就像你去住酒店,你下单提供了你的手机号,然后到酒店了给你一个房卡,你知道了你的房号之后再根据这个房号去找对应的房间一样。

房号就是key,房间里就是value。你通过手机号下单到酒店给你房号可以理解为对key哈希的过程。你找的过程就是HashMap根据key取到对应value的过程

HashMap底层结构

table数组

首先我们要知道,我们存在HashMap中的数据最终是存了什么地方,就是如下的结构。

transient HashMap.Node<K, V>[] table;

可能有人看到transient有些陌生,被这个关键字修饰的变量将不会被序列化。简单来说,就是序列化之后这个字段的值就会被干掉,用于一些不需要传递给第三方的字段。

例如一个矩形,在本地使用的时候,有长、宽和面积三个属性,但是你要把这个对象给第三方用,但是由于面积可以通过另外两个属性推导出来,这个key就不需要传递给第三方了。

这种情况就可以用transient关键字修饰。总的来说就是,被transient修饰的变量将不再参与序列化。

Node节点

下面是Node节点的定义。

static class Node<KVimplements Entry<KV{
        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 V getValue() {
            return value;
        }

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

              ......
    }

上面的代码省略了一些GetterSetter,结构还是非常清晰和简单。可以看到这个节点存储了下一个节点的对象的引用,形成了一个链表的结构。

为什么要用链表?用数组不行吗?刚刚上面提到过,这个集合是由链表和数组组成的。因为再完美的hash算法都有可能产生哈希冲突,所以两个不同key的元素可以被放在同一个地方。

而单用数组明显不能满足这个需求,而在数组的槽位上存一个链表就可以解决这个问题。

HashMap的使用

上面简单了解了HashMap的定义和基本的底层数据结构,接下来通过HashMap在平常开发中的使用来具体看看怎么实现的。

Map<String, String> map = new HashMap<>();

map.put("搜索关注公众号""SH的全栈笔记"); // 设置值
map.get("搜索关注公众号");               // SH的全栈笔记 

赋值

put函数

上面的Put方法,我们传入了两个参数,Key和Value,函数的定义如下。

java public V put(K key, V value) { return this.putVal(hash(key), key, value, false, true); }

应该跟大多数人YY的put方法差不多,put方法再调用了putVal 方法。

首先经过了hash之后的key,是一个整型的hashcode,其次是我们传入的key和value。最后两个布尔值,后面会提到。

首先一进入putVal就会声明存放数据的table,如果这个HashMap是首次设置值,就会被初始化一个默认size的table,且所有元素的初始值都是NULL,下面是初始化这块的核心代码,我省略掉了一些无关的变量声明。

有趣的是,初始化调用的是resize方法。

Node<K,V>[] tab; 
int n;
if ((tab = table) == null || (n = tab.length) == 0) {
  n = (tab = resize()).length;
}

newCap = 16// 默认容量
newThr = 12// 默认阈值

默认值为啥是16

上面初始化table的默认size给的是16,当然我们也可以自己定义,但是建议是最好是2的幂。有的朋(杠)友(精)就要问了,为什么是16呢?我13,14不他不香吗?我们接下来就要分析为什么不香。

当我们放元素进入map的时候,它是如何确定元素在table数组中的位置的呢?我们拿搜索关注公众号这个key举例。

hash = (h = key.hashCode()) ^ h >>> 16
p = tab[i = n - 1 & hash]

可以看到,是将hash之后key和数组的length-1做与运算得到了一个数组下标。而且,hash值的二进制的位数,大多数情况下都会比table的长度的二进制位数多。换句话说,与运算之后得到的数组下标index完全取决于hash值的后几位。

16 // n   10000
15 // n-1 1111
14 //     1110
13 //     1101
12 //     1100
11 //     1011
10 //     1010

从13、14的二进制值可以看出来,存在0和1在二进制位数上分布不均匀的情况,这样一来就会造成一个问题,那就是会存在某些不同的hash值经过与运算得到的值是一样的。这样就会导致hash到的index不均匀,换句话说有些index可能永远都不会被hash到,而有些index也被频繁的hash到。

本来hash算法是要求计算的结果要均匀分布的,但是上述的结果明显不符合均匀分布的要求。用n-1而不用n也是因为同样的道理。如果这个值是2的幂,那么2的幂的值-1的所有二进制位数都是1,这样有利于hash计算的均匀分布。

综上所述,不一定是16,2的幂都可以,16只是一个经验值。

自动扩容

除了size,初始化的时候还会设定一个阈值,值为12,newThr = 12,这里需要提到一个概念负载因子,HashMap的实现里默认给的是0.75。

public HashMap() {
  this.loadFactor = 0.75F// 12/16=0.75
}

负载因子是用来干嘛的呢?最开始我们提到了,最开始存储的数据结构是数组,这种基础结构是有size设定的。当我们不停的往map里存数据的时候,总会存满,当元素快存满的时候,我们就需要扩大map的容量,来容纳更多的元素,这就需要一个自动扩容的机制了。

不是扩容弹匣,想啥呢

在当数据量大于超过设定的阈值的时候(容量*负载因子),自动对map进行扩容,以存放更多的数据。

自动扩容做了什么事情呢?总结来说就是两件事。

  • 创建新的数组,大小是原来数组的一倍。
  • 将元素rehash到新的数组

为什么要rehash呢?上面我们提到过了,当元素被放进map时,确认下标的方法是table的长度-1hash值做与运算,现在table的长度发生了变化,那么自然而然,元素获取下标的运算结果也就跟之前的不一样了, 所以需要将老的map中的元素再按照新的table长度rehash到扩容后的table中。

所以在当你对性能有一定要求,且你知道你创建map的时候size的时候,可以指定size,这样一来就不会因为数据量持续的增大而去频繁的自动扩容了

put的过程中到底发生了什么

了解了底层数据结构自动扩容机制,接下来我们来看一下put过程中究竟发生了什么。我们上面说过了,会通过数组的长度-1hash值与运算得到一个数组下标。

如果该位置没有元素,那么就很简单,直接新建一个节点即可然后放置在数据的具体位置即可。

tab[i] = this.newNode(hash, key, value, (HashMap.Node)null);

但是如果该下标已经有元素了,这种情况HashMap是怎么处理的呢?这也要看情况。

  • 如果是跟当前槽位相同的key,就直接覆盖。这就是我们修改某个key的值会发生的情况。那HashMap怎么来判断是不是同一个key呢?就像下面这样。p就是当前槽位上已经有的元素,如果新、老元素的key的hashCode都相同且key不为空,那么就能证明这两个key是相同的,那么此时只需要覆盖即可。

    p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))

  • 而如果p是TreeNode的实例,那么就代表当前槽位已经是一个红黑树了,此时只需要往这个树里putTreeVal即可。至于为什么是红黑树,哪儿来的红黑树,下面马上就要讲到了。

  • 最后一种情况就是,既不是已经存在的元素也不是TreeNode的实例,也不是红黑树。这种情况下,它就是一个普通的Node。你可以理解为链表,如果hash冲突了,就把这个Node放到该位置的链表末尾。Java8之前采用的头插法,而Java8换成了尾插法,至于为什么要换,后面会讲。

当该位置的链表中的元素超过了TREEIFY_THRESHOLD所设置的数量时,就会触发树化,将其转化为红黑树。Java8里给的默认值是8。

为啥要转化成红黑树

首先我们要知道为什么要树化。当大量的数据放入Map中,Hash冲突会越来越多,某些位置就会出现一个很长的链表的情况。这种情况下,查询时间复杂度是O(n) ,删除的时间复杂度也是O(n),查询、删除的效率会大大降低。而同样的数据情况下,平衡二叉树的时间复杂度都是O(logn)。

有的朋(杠)友(精)看到这个小标题不乐意了,怎么就直接用红黑树了?我用二叉查找树它不香吗?

不了解二叉查找树的,我把它的特点列在了下面。

  • 左子树上的所有节点的值都小于根节点的值

  • 右子树上的所有节点的值都大于根节点的值

再精简一下就是,左小右大

但是,如果数据大量的趋近于有序,例如所有的节点都比根节点大,那这个时候二叉查找树就退化成了链表,查询效率就会急剧下降。看到这是不是觉得有点不对,我才从链表树化,你这又给我退化成了链表?

朋友看到这又不乐意了,好好好,就算二叉查找树不行,那AVL树它也不行?用了AVL树就不会出现上面所描述的效率急剧退化的情况了不是吗?

的确是这样,AVL也可以叫平衡二叉搜索树。AVL树会在其有退化成链表的趋势的时候(左右子树的高度差超过某个阈值)调整树的结构,也就是通过左旋和右旋来使其左右子树的高度尽量平衡。

OK,OK,就算你解释清楚了为什么要树化,那为什么一定要用红黑树

具体的细节也就不在这里赘述,不知不觉已经写了这么多了,直接说结论吧。AVL树的查找速度更快,但是相应的插入和修改的速度较慢。而红黑树则在插入和修改操作较为密集的时候表现更好。

而总结我们日常的HashMap使用,大多数情况下插入和修改应该是比查找更频繁一些的。而在这种情况下,红黑树的综合表现会更好一些。

至于红黑树的相关细节,涉及的东西还是挺多,我之后会单独拿一个篇幅来讲。

为什么要用尾插法

我们目前用的最多的是Java8,在Java8中采用的是尾插法,Java8之前采用的是头插法。

那为什么后面又变成了尾插法呢?放心,肯定不是设计者闲的蛋疼,没事来改个设计。这样做一定是有一定的道理的。在解释这个问题之前,我们先来看看,如果采取头插法在多线程下的情况下会出现什么问题。

我们讲过,假设数组中index=1的位置已经有了元素A,之后又有元素B被分配到了index=1的位置。那么在下标为1的槽位上的链表就变成了B -> A。

此时再分配了一个新元素C,链表又被更新成了C -> B -> A。这也是为什么叫头插法,新的元素会被放在链表的头节点,因为当时设计的时候考虑到后被放入map的元素被访问的可能性更大。

上面讲到了在当不停的往map中放置元素后,超过了设定的阈值,就会触发自动扩容。此时会触发两个操作,一是创建一个容量为之前两倍的底层数组,并且将老的数组中的元素rehash到新的数组中。

而由于数组的长度发生了变化,这就导致了元素的rehash结果跟之前在老数组中的位置不一样。

首先我们来模拟一下rehash的过程,假设新的数组中下标为2的槽位是空的。

  • 首先元素C,被放置在了其他位置。

  • 然后元素B,被rehash到了下标为2的槽位, 至此都没有问题。

  • 最后元素A,同样被rehash到了下标为2的槽位,此时链表变成了A -> B。到这就有问题了,最开始B的next指向的是A节点。但是rehash之后A的next又指向B,看到这你应该就能明白发生了什么。

我看到很多的对JDK1.7版的HashMap在多线程的情况下扩容会出现死锁的解释都只到了环形链表。但是其实就算是环形链表,只要找到了对应的元素,就会直接退出循环的逻辑,也不会造成死循环。

实际情况是,当自动扩容形成了环形链表后,当你去Get了一个在entry链上不存在的元素时,就会出现死循环的情况。

取值

上面聊了给HashMap赋值的大概过程,接下来聊一下从HashMap获取值会发生什么。get方法的开始,跟put一样很简单。

public V get(Object key) {
  Node<K,V> e;
  return (e = getNode(hash(key), key)) == null ? null : e.value;
}

可以看到,取值的核心操作是getNode来负责完成的。

首先第一件事就是去check的第一个元素是不是当前查找的元素。

如果不是,而且当前槽位已经被树化成了红黑树,就走红黑树的getTreeNode方法。

如果还没有被树化,只是普通的链表,则顺着next一路找下去。

由于get方法逻辑和实现都比较容易理解,就不贴太多源码了。

结尾

由于最近太忙了,工作和生活中的事都巨多,这篇文章是几周利用零零散散的时间写出来的,如果有什么问题,欢迎大家在评论区讨论。

如果你觉得这篇文章对你有帮助,还麻烦点个赞关个注分个享留个言

也可以微信搜索公众号【SH的全栈笔记】,当然也可以直接扫描二维码关注

拜了个拜

posted @ 2020-04-21 08:45  detectiveHLH  阅读(...)  评论(...编辑  收藏