HashMap原理分析 HashMap原理分析

个人专题目录： ActiviMQ专题
链路追踪
Dubbo专题
Docker专题
Git专题
Idea专题
Java阿里P6+必会专题
Java工具类
Kafka专题
Linux专题
Maven专题
Markdown专题
Mysql专题
Netty专题
Nginx专题
Openstack专题
Redis专题
Spring专题
SpringBoot专题
SpringCloud专题
Zookeeper专题
个人随笔专题
数据结构专题
单点登录专题
【HashMap原理分析】设计模式专题
架构优化专题
一、概述哈希表是基于Map接口的实现的，它允许null值和null键，它不是线程同步的，同时也不保证有序。
Map的这种实现方式为get（取）和put（存）带来了比较好的性能。但是如果涉及到大量的遍历操作的话，就尽量不要把capacity设置得太高（或load factor设置得太低），否则会严重降低遍历的效率。
影响HashMap性能的两个重要参数：“initial capacity”（初始化容量）和”load factor“（负载因子）。简单来说，容量就是哈希表桶的个数，负载因子就是键值对个数与哈希表长度的一个比值，当比值超过负载因子之后，HashMap就会进行rehash操作来进行扩容。
HashMap 的大致结构如下图所示，其中哈希表是一个数组，我们经常把数组中的每一个节点称为一个桶，哈希表中的每个节点都用来存储一个键值对。在插入元素时，如果发生冲突（即多个键值对映射到同一个桶上）的话，就会通过链表的形式来解决冲突。因为一个桶上可能存在多个键值对，所以在查找的时候，会先通过key的哈希值先定位到桶，再遍历桶上的所有键值对，找出key相等的键值对，从而来获取value。

文章图片
clip_image002.png （因为我这里主要介绍的是Java对HashMap的实现，而不是hash算法，所以如果对哈希算法不了解，建议先去学习一下！）
二、属性再来看看HashMap类中包含了哪些重要的属性，这对下面介绍HashMap方法的实现有一定的参考意义。

//默认的初始容量为16 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //最大的容量上限为2^30 static final int MAXIMUM_CAPACITY = 1 << 30; //默认的负载因子为0.75 static final float DEFAULT_LOAD_FACTOR = 0.75f; //变成树型结构的临界值为8 static final int TREEIFY_THRESHOLD = 8; //恢复链式结构的临界值为6 static final int UNTREEIFY_THRESHOLD = 6; //哈希表 transient Node[] table; //哈希表中键值对的个数 transient int size; //哈希表被修改的次数 transient int modCount; //它是通过capacity*load factor计算出来的，当size到达这个值时，就会进行扩容操作 int threshold; //负载因子 final float loadFactor; //当哈希表的大小超过这个阈值，才会把链式结构转化成树型结构，否则仅采取扩容来尝试减少冲突 static final int MIN_TREEIFY_CAPACITY = 64;

下面是 Node 类的定义，它是 HashMap 中的一个静态内部类，哈希表中的每一个节点都是 Node 类型。我们可以看到，Node 类中有 4 个属性，其中除了 key 和 value 之外，还有 hash 和 next 两个属性。hash 是用来存储 key 的哈希值的，next 是在构建链表时用来指向后继节点的。

static class Node implements Map.Entry { final int hash; final K key; V value; Node next; Node(int hash, K key, V value, Node next) { this.hash = hash; this.key = key; this.value = https://www.it610.com/article/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 = https://www.it610.com/article/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; } }

三、方法 1、get方法

//get方法主要调用的是getNode方法，所以重点要看getNode方法的实现 public V get(Object key) { Node e; return (e = getNode(hash(key), key)) == null ? null : e.value; }final Node getNode(int hash, Object key) { Node[] tab; Node first, e; int n; K k; //如果哈希表不为空 && key对应的桶上不为空 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { //是否直接命中 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; //判断是否有后续节点 if ((e = first.next) != null) { //如果当前的桶是采用红黑树处理冲突，则调用红黑树的get方法去获取节点 if (first instanceof TreeNode) return ((TreeNode)first).getTreeNode(hash, key); //不是红黑树的话，那就是传统的链式结构了，通过循环的方法判断链中是否存在该key do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null; }

实现步骤大致如下：

通过hash值获取该key映射到的桶。
桶上的key就是要查找的key，则直接命中。
桶上的key不是要查找的key，则查看后续节点：
如果后续节点是树节点，通过调用树的方法查找该key。
如果后续节点是链式节点，则通过循环遍历链查找该key。

2、put方法

//put方法的具体实现也是在putVal方法中，所以我们重点看下面的putVal方法 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[] tab; Node 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 e; K k; //如果桶上节点的key与当前key重复，那你就是我要找的节点了 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //如果是采用红黑树的方式处理冲突，则通过红黑树的putTreeVal方法去插入这个键值对 else if (p instanceof TreeNode) e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value); //否则就是传统的链式结构 else { //采用循环遍历的方式，判断链中是否有重复的key for (int binCount = 0; ; ++binCount) { //到了链尾还没找到重复的key，则说明HashMap没有包含该键 if ((e = p.next) == null) { //创建一个新节点插入到尾部 p.next = newNode(hash, key, value, null); //如果链的长度大于TREEIFY_THRESHOLD这个临界值，则把链变为红黑树 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } //找到了重复的key 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 = https://www.it610.com/article/e.value; if (!onlyIfAbsent || oldValue == null) e.value = value; afterNodeAccess(e); return oldValue; } } ++modCount; //判断是否需要进行扩容 if (++size> threshold) resize(); afterNodeInsertion(evict); return null; }

put方法比较复杂，实现步骤大致如下：

先通过hash值计算出key映射到哪个桶。
如果桶上没有碰撞冲突，则直接插入。
如果出现碰撞冲突了，则需要处理冲突：
如果该桶使用红黑树处理冲突，则调用红黑树的方法插入。
否则采用传统的链式方法插入。如果链的长度到达临界值，则把链转变为红黑树。
如果桶中存在重复的键，则为该键替换新值。
如果size大于阈值，则进行扩容。

3、remove方法
理解了put方法之后，remove已经没什么难度了，所以重复的内容就不再做详细介绍了。

//remove方法的具体实现在removeNode方法中，所以我们重点看下面的removeNode方法 public V remove(Object key) { Node e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; }final Node removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable) { Node[] tab; Node p; int n, index; //如果当前key映射到的桶不为空 if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node node = null, e; K k; V v; //如果桶上的节点就是要找的key，则直接命中 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; else if ((e = p.next) != null) { //如果是以红黑树处理冲突，则构建一个树节点 if (p instanceof TreeNode) node = ((TreeNode)p).getTreeNode(hash, key); //如果是以链式的方式处理冲突，则通过遍历链表来寻找节点 else { do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) { node = e; break; } p = e; } while ((e = e.next) != null); } } //比对找到的key的value跟要删除的是否匹配 if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) { //通过调用红黑树的方法来删除节点 if (node instanceof TreeNode) ((TreeNode)node).removeTreeNode(this, tab, movable); //使用链表的操作来删除节点 else if (node == p) tab[index] = node.next; else p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } } return null; }

4、hash方法
在get方法和put方法中都需要先计算key映射到哪个桶上，然后才进行之后的操作，计算的主要代码如下：

(n - 1) & hash

上面代码中的n指的是哈希表的大小，hash指的是key的哈希值，hash是通过下面这个方法计算出来的，采用了二次哈希的方式，其中key的hashCode方法是一个native方法：

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

这个hash方法先通过key的hashCode方法获取一个哈希值，再拿这个哈希值与它的高16位的哈希值做一个异或操作来得到最后的哈希值，计算过程可以参考下图。为啥要这样做呢？注释中是这样解释的：如果当n很小，假设为64的话，那么n-1即为63（0x111111），这样的值跟hashCode()直接做与操作，实际上只使用了哈希值的后6位。如果当哈希值的高位变化很大，低位变化很小，这样就很容易造成冲突了，所以这里把高低位都利用起来，从而解决了这个问题。

文章图片
1544784905887.png 正是因为与的这个操作，决定了HashMap的大小只能是2的幂次方，想一想，如果不是2的幂次方，会发生什么事情？即使你在创建HashMap的时候指定了初始大小，HashMap在构建的时候也会调用下面这个方法来调整大小：

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

这个方法的作用看起来可能不是很直观，它的实际作用就是把cap变成第一个大于等于2的幂次方的数。例如，16还是16，13就会调整为16，17就会调整为32。
5、resize方法
HashMap在进行扩容时，使用的rehash方式非常巧妙，因为每次扩容都是翻倍，与原来计算（n-1）&hash的结果相比，只是多了一个bit位，所以节点要么就在原来的位置，要么就被分配到“原位置+旧容量”这个位置。
例如，原来的容量为32，那么应该拿hash跟31（0x11111）做与操作；在扩容扩到了64的容量之后，应该拿hash跟63（0x111111）做与操作。新容量跟原来相比只是多了一个bit位，假设原来的位置在23，那么当新增的那个bit位的计算结果为0时，那么该节点还是在23；相反，计算结果为1时，则该节点会被分配到23+31的桶上。
正是因为这样巧妙的rehash方式，保证了rehash之后每个桶上的节点数必定小于等于原来桶上的节点数，即保证了rehash之后不会出现更严重的冲突。

final Node[] resize() { Node[] 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; // double threshold } 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); } //新的resize阈值 threshold = newThr; //创建新的哈希表 @SuppressWarnings({"rawtypes","unchecked"}) Node[] newTab = (Node[])new Node[newCap]; table = newTab; if (oldTab != null) { //遍历旧哈希表的每个桶，重新计算桶里元素的新位置 for (int j = 0; j < oldCap; ++j) { Node 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)e).split(this, newTab, j, oldCap); //如果采用链式处理冲突 else { // preserve order Node loHead = null, loTail = null; Node hiHead = null, hiTail = null; Node 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; }

在这里有一个需要注意的地方，有些文章指出当哈希表的桶占用超过阈值时就进行扩容，这是不对的；实际上是当哈希表中的键值对个数超过阈值时，才进行扩容的。
四、总结通过红黑树的方式来处理哈希冲突。
按照原来的拉链法来解决冲突，如果一个桶上的冲突很严重的话，是会导致哈希表的效率降低至O（n），而通过红黑树的方式，可以把效率改进至O（logn）。相比链式结构的节点，树型结构的节点会占用比较多的空间，所以这是一种以空间换时间的改进方式。