HashMap源码及原理详解(hashmap的源码,实现原理,底层结构)

  本篇文章为你整理了HashMap源码及原理详解(hashmap的源码,实现原理,底层结构)的详细内容,包含有hashmap的源码,实现原理,底层结构 hashmap的源码,实现原理,底层结构 hashmap1.7源码分析 hashmap1.8源码 HashMap源码及原理详解,希望能帮助你了解 HashMap源码及原理详解。

  HashMap用来存放键值对,是Map接口的实现,是非线程安全的

  可以存储key和value为null的值,但key为null的节点只能有一个

  哈希值的计算:在hashCode的基础上添加扰动函数,使元素分布更加随机

  哈希冲突:通过链表存储具有相同索引的元素,JDK1.8引入红黑树解决链表过长查询效率慢的问题

  总是以2的幂次方作为哈希表大小,用于优化key的哈希值的计算过程,默认初始容量为16;

  2倍扩容,JDK 1.8优化了key的数组下标的计算过程;JDK 1.8使用尾插法代替头插法,避免循环链表问题

  
JDK1.8 HashMap数据结构图

  

public class HashMap K,V extends AbstractMap K,V implements Map K,V , Cloneable, Serializable {

 

   // 序列号

   private static final long serialVersionUID = 362498820763181265L;

   // 默认的初始容量是16

   static final int DEFAULT_INITIAL_CAPACITY = 1 4;

   // 最大容量

   static final int MAXIMUM_CAPACITY = 1 30;

   // 默认的填充因子

   static final float DEFAULT_LOAD_FACTOR = 0.75f;

   // 当桶(bucket)上的结点数大于这个值时会转成红黑树

   static final int TREEIFY_THRESHOLD = 8;

   // 当桶(bucket)上的结点数小于这个值时树转链表

   static final int UNTREEIFY_THRESHOLD = 6;

   // 桶中结构转化为红黑树对应的table的最小容量

   static final int MIN_TREEIFY_CAPACITY = 64;

   // 存储元素的数组,总是2的幂次倍

   transient Node k,v [] table;

   // 存放具体元素的集

   transient Set map.entry k,v entrySet;

   // 存放元素的个数,注意这个不等于数组的长度。

   transient int size;

   // 每次扩容和更改map结构的计数器

   transient int modCount;

   // 临界值(容量*填充因子) 当实际大小超过临界值时,会进行扩容

   int threshold;

   // 加载因子

   final float loadFactor;

   //......

  

 

  loadFactor:加载因子,用于控制数据存放的密度,默认值为0.75。如果哈希表的数据分布过于密集,会导致查找效率下降。

  threshold:HashMap所能容纳的最大数据量的Node(键值对)个数,当size threshold(注意这里是元素的个数,不是数组的长度),执行扩容(resize())的逻辑。threshold=capacity * loadFactor,

  Node节点源码

  

// 继承自 Map.Entry K,V 

 

  static class Node K,V implements Map.Entry K,V {

   final int hash;// 哈希值,存放元素到hashmap中时用来与其他元素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; }

   // 重写hashCode()方法

   public final int hashCode() {

   return Objects.hashCode(key) ^ Objects.hashCode(value);

   public final V setValue(V newValue) {

   V oldValue = value;

   value = newValue;

   return oldValue;

   // 重写 equals() 方法

   public final boolean equals(Object o) {

   if (o == this)

   return true;

   if (o instanceof Map.Entry) {

   Map.Entry ?,? e = (Map.Entry ?,?

   if (Objects.equals(key, e.getKey())

   Objects.equals(value, e.getValue()))

   return true;

   return false;

  

 

  TreeNode节点源码

  

 static final class TreeNode K,V extends LinkedHashMap.Entry K,V {

 

   TreeNode K,V parent; // 父

   TreeNode K,V left; // 左

   TreeNode K,V right; // 右

   TreeNode K,V prev; // needed to unlink next upon deletion

   boolean red; // 判断颜色

   TreeNode(int hash, K key, V val, Node K,V next) {

   super(hash, key, val, next);

   // 返回根节点

   final TreeNode K,V root() {

   for (TreeNode K,V r = this, p;;) {

   if ((p = r.parent) == null)

   return r;

   r = p;

   //......

  

 

  容量初始化

  HashMap会保证容量(数组长度)为2的幂次方,默认容量为16。如果创建时,指定了容量,会转换成就近的、大于等于指定容量的2次幂的容量。如:传入的容量为10会转换成16(2^4)。

  

 static final int tableSizeFor(int cap) {

 

   int n = cap - 1;

   n = n

   n = n

   n = n

   n = n

   n = n

   return (n 0) ? 1 : (n = MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

  

 

  容量为2的幂次方的好处

  1. 计算key对应的数组下标更加高效

  因为 运算比%运算计算的效率更高,源码中并不是通过key.hashCode()%table.length计算key对应的下标的,而是通过 的方式。

  

key.hashCode() (table.length-1)

 

  

 

  之所以可以使用 代替%是因为将容量设置为2的幂次方,这样table.length-1转换成二进制就能得到高位全部是0,低位全部是1的二进制,用于 运算。如下是table.length=16计算示例:

  

 10100101 11000100 00100101

 

   00000000 00000000 00001111

  ----------------------------------

   00000000 00000000 00000101 //高位全部归零,只保留末四位

  

 

  2. 扩容时更加高效

  在哈希表做扩容时,需要重新计算每个节点的哈希值。通过容量为2的幂次方和二倍扩容的机制,可以实现高效的计算哈希值的优化。请查看resize()部分。

  哈希的计算

  HashMap是通过hashCode去计算数组索引的,从而访问元素,无论是get()、put()都需要先计算元素对应的哈希值。

  另外,为了减少哈希冲突,使节点分布的更加均匀,HashMap并不是直接使用key.hashCode()作为哈希值,而是添加了扰动函数,把(h = key.hashCode()) ^ (h 16)的计算结果作为哈希值,执行key.hashCode的高16位和低16位的异或运算。

  

 static final int hash(Object key) {

 

   int h;

   // key.hashCode():返回散列值也就是hashcode

   // ^ :按位异或

   // :无符号右移,忽略符号位,空位都以0补齐

   return (key == null) ? 0 : (h = key.hashCode()) ^ (h 16);

  

 

  
如果链表长度大于阈值(默认为8),且哈希表的数组长度大于或等于64时,会转换成红黑树,减少搜索时间;否则,执行resize()对数组扩容。

  
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 int n, i;

   // table未初始化或者长度为0,进行扩容

   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 K k;

   // 比较桶中第一个元素(数组中的结点)的hash值相等,key相等

   if (p.hash == hash

   ((k = p.key) == key (key != null key.equals(k))))

   // 将第一个元素赋值给e,用e来记录

   e = p;

   // hash值不相等,即key不相等;为红黑树结点

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

   // 结点数量达到阈值(默认为 8 ),执行 treeifyBin 方法

   // 这个方法会根据 HashMap 数组来决定是否转换为红黑树。

   // 只有当数组长度大于或者等于 64 的情况下,才会执行转换红黑树操作,以减少搜索时间。否则,就是只是对数组扩容。

   if (binCount = TREEIFY_THRESHOLD - 1) // 减1,是因为头节点要计算在内,所以链表长度需要达到TREEIFY_THRESHOLD,才会调用treeifyBin

   treeifyBin(tab, hash);

   // 跳出循环

   break;

   // 判断链表中结点的key值与插入的元素的key值是否相等

   if (e.hash == hash

   ((k = e.key) == key (key != null key.equals(k))))

   // 相等,跳出循环

   break;

   // 用于遍历桶中的链表,与前面的e = p.next组合,可以遍历链表

   p = e;

   // 表示在桶中找到key值、hash值与插入元素相等的结点

   if (e != null) {

   // 记录e的value

   V oldValue = e.value;

   // onlyIfAbsent为false或者旧值为null

   if (!onlyIfAbsent oldValue == null)

   //用新值替换旧值

   e.value = value;

   // 访问后回调

   afterNodeAccess(e);

   // 返回旧值

   return oldValue;

   // 结构性修改

   ++modCount;

   // 实际大小大于阈值则扩容

   if (++size threshold)

   resize();

   // 插入后回调

   afterNodeInsertion(evict);

   return null;

  

 

  说明:

  在访问元素的过程中,先比较key.hashCode,如果hashCode不相等,就直接跳过;否则,再调用key.equals()比较元素。这么做的好处是hashCode的比较效率要高于调用equals()。

  JDK 1.8在链表的基础上添加了红黑树,当数组长度 =64,且链表长度 =8时,就会将链表转换成红黑树。

  扩容的触发条件:

  元素个数大于 threshold

  treeifyBin()方法中,数组长度 64

  
final Node K,V getNode(int hash, Object key) {

   Node K,V [] tab; Node K,V first, e; int n; K k;

   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 K,V )first).getTreeNode(hash, key);

   // 在链表中get

   do {

   if (e.hash == hash

   ((k = e.key) == key (key != null key.equals(k))))

   return e;

   } while ((e = e.next) != null);

   return null;

  

 

 

  
resize - 数组扩容

  resize()用于数组扩容,需要新建一个数组,然后遍历原数组,重新计算数组下标,迁移元素,非常耗时,应该尽量避免该操作。

  

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;

   // 没超过最大值,就扩充为原来的2倍

   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 {

   // signifies using defaults

   newCap = DEFAULT_INITIAL_CAPACITY;

   newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);

   // 计算新的resize上限

   if (newThr == 0) {

   float ft = (float)newCap * loadFactor;

   newThr = (newCap MAXIMUM_CAPACITY ft (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);

   threshold = newThr;

   //创建新的数组

   Node K,V [] newTab = (Node K,V [])new Node[newCap];

   table = newTab;

   if (oldTab != null) {

   // 把每个bucket都移动到新的buckets中

   for (int j = 0; j oldCap; ++j) {

   Node K,V

   //对不为空的bucket执行迁移

   if ((e = oldTab[j]) != null) {

   oldTab[j] = null;

   //bucket中仅有一个节点,直接迁移

   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 {

   //链表的节点迁移

   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;

   // 新的索引=原索引+oldCap

   else {

   if (hiTail == null)

   hiHead = e;

   else

   hiTail.next = e;

   hiTail = e;

   } while ((e = next) != null);

   // 原索引放到bucket里

   if (loTail != null) {

   loTail.next = null;

   newTab[j] = loHead;

   // 原索引+oldCap放到bucket里

   if (hiTail != null) {

   hiTail.next = null;

   newTab[j + oldCap] = hiHead;

   return newTab;

  

 

  可以看到扩容的方式,并不会改变节点原先在链表中的顺序,即尾插法。

  JDK 1.8优化了key的哈希计算过程

  JDK 1.8的resize()优化了key的哈希计算过程。

  优化的前提:

  哈希表的长度为2的幂次方

  哈希表的扩容为2倍扩容

  HashMap扩容后,newCap=2*oldCap,那么key.hash (newCap -1)计算新的下标时,mask会在高位多个1。而key在这个位置的值不是0就是1,如果是0,那么新的数组下标=原来数组下标;如果是1,那么新的数组下标=原数组下标+oldCap。

  
 

  JDK 1.8的尾插的优化,解决环形链表问题

  JDK 1.8扩容时,使用尾插代替JDK 1.7的头插法,不会改变节点原有的顺序,避免了多线程下环形链表的问题。

  JDK 1.7头插法扩容和环形链表问题

  以下为JDK 1.7的扩容源码

  

 1 void resize(int newCapacity) { //传入新的容量

 

   2 Entry[] oldTable = table; //引用扩容前的Entry数组

   3 int oldCapacity = oldTable.length;

   4 if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了

   5 threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1),这样以后就不会扩容了

   6 return;

   9 Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组

  10 transfer(newTable); //!!将数据转移到新的Entry数组里

  11 table = newTable; //HashMap的table属性引用新的Entry数组

  12 threshold = (int)(newCapacity * loadFactor);//修改阈值

  

 

  

 1 void transfer(Entry[] newTable) {

 

   2 Entry[] src = table; //src引用了旧的Entry数组

   3 int newCapacity = newTable.length;

   4 for (int j = 0; j src.length; j++) { //遍历旧的Entry数组

   5 Entry K,V e = src[j]; //取得旧Entry数组的每个元素

   6 if (e != null) {

   7 src[j] = null;//释放旧Entry数组的对象引用(for循环后,旧的Entry数组不再引用任何对象)

   8 do {

   9 Entry K,V next = e.next;

  10 int i = indexFor(e.hash, newCapacity); //重新计算每个元素在数组中的位置

  11 e.next = newTable[i]; //这里要插入的节点的下一个节点直接设置成了当前链表的头节点

  12 newTable[i] = e; //将元素放在数组上

  13 e = next; //访问下一个Entry链上的元素

  14 } while (e != null);

  

 

  transfer()的11和12行代码展示了头插的方式,即原链表在扩容之后,被反转了。(可以打个断点演示一下这个过程就清楚了。)

  容量为2的HashMap扩容示例

  可以看到链表反转了,即原先是{5,9}的顺序,扩容后,顺序变为{9,5}。

  循环链表问题

  在多个线程同时扩容时,头插法可能形成环形链表,造成死循环。具体实例可以参考Java 8系列之重新认识HashMap

  https://zhuanlan.zhihu.com/p/21673805

  https://javaguide.cn/java/collection/hashmap-source-code.html

  https://mp.weixin.qq.com/s/oRx-8XXbgage9Hf97WrDQQ

  以上就是HashMap源码及原理详解(hashmap的源码,实现原理,底层结构)的详细内容,想要了解更多 HashMap源码及原理详解的内容,请持续关注盛行IT软件开发工作室。

郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: