HashMap源码分析

最新推荐文章于 2023-04-12 15:35:40 发布
最新推荐文章于 2023-04-12 15:35:40 发布
阅读量303 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42933931/article/details/114133905
版权

有参构造方法

//负载因子
 static final float DEFAULT_LOAD_FACTOR = 0.75f;
//最大容量
 static final int MAXIMUM_CAPACITY = 1 << 30;
 
 public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

//用来校验参数loadFactor是不是一个NAN,如果参数是NAN,(v != v)成立，返回true
//比如float loadFactor = 0.0f,返回true
  public static boolean isNaN(float v) {
      return (v != v);
  }
 public HashMap(int initialCapacity, float loadFactor) {
       if (initialCapacity < 0) // 如果初始化容量小于0，非法参数异常
           throw new IllegalArgumentException("Illegal initial capacity: " +
                                              initialCapacity);
     //如果初始化容量大小大于2的30次方，那么容量初始化大小等于2的30次方。
       if (initialCapacity > MAXIMUM_CAPACITY)
           initialCapacity = MAXIMUM_CAPACITY;
       if (loadFactor <= 0 || Float.isNaN(loadFactor))
       //如果负载因子小于0或者 Float.isNaN(loadFactor) 为true的情况下 ，参数校验也会不通过。
           throw new IllegalArgumentException("Illegal load factor: " +
                                              loadFactor);
       this.loadFactor = loadFactor;
       this.threshold = tableSizeFor(initialCapacity);
   }
}

重点研究tableSizeFor()方法

自定义Map<Object, Object> map = new HashMap<>(8);
有参构造，我尝试初始化initialCapacity多个不同的值，但是每次initialCapacity都是等于11，这一点我是还没明白？如下截图。

在这里插入图片描述
假设initialCapacity=11，调用tableSizeFor方法。n |= n >>> 1;;表示n或运算n右移1位后的值。

static final int tableSizeFor(int cap) {
       
	  int n = cap - 1;
	
	  //0000 1010 右移1位 0000 0101 转成10进制等于5 
      //0000 1010  或 0000 0101  等于  0000 1111 转成10进制 此时n=15
	  n |= n >>> 1;
	 //0000 1111 右移2位 0000 0011 
	 //0000 1111 或 0000 0011  等于 0000 1111 转成10进制 此时n仍然为15
     //以此类推 只要低四位为1111  或 0000 xxxx   后面低四位都是1111 
       ...
     //所以最后n经过最终的位运算，仍然等于15。  
	  n |= n >>> 2;
	  n |= n >>> 4;
	  n |= n >>> 8;
	  n |= n >>> 16;
	  //三元运算 最终返回的值是取n+1正好等于16
	  return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;

tableSizeFor返回值16，正好赋值给阈值threshold变量。

根据key，计算hash值的方法

 String  key = "李四";

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

在这里插入图片描述

计算key对应的索引下标

p = tab[i = (n - 1) & hash]

在这里插入图片描述

为什么数组的长度是2的指数次幂？（个人理解）

在这里插入图片描述

如果不是2的指数次方幂？（导致hash碰撞，键值分布不均匀）

在这里插入图片描述

空参构造方法

new一个map容器 Map<String, Integer> map = new HashMap<>();
初始化的时候会去掉一个resize()扩容方法。debugger看了一下。
在这里插入图片描述
初始化newCap=16,static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
在这里插入图片描述
初始化newThr=12， 16*0.75=12
在这里插入图片描述
然后将threshold赋值为12，定义一个长度newCap=16的数组
在这里插入图片描述
直接返回newTab 数组
在这里插入图片描述

put()方法

 Map<String, Integer> map = new HashMap<>();
 map.put("张三",100);

map初始化已经完成，put元素不会在进这个判断。
在这里插入图片描述

  • 根据数组长度和key的hash值&运算得出索引，然后判断此索引位置是否存在元素，如果不存在，则将元素存放在此。new一个node节点元素。

在这里插入图片描述

  • 存放此索引位置的元素的key和新的元素的key相等，并且hash值也相等，Node<K,V> e = p;

在这里插入图片描述

  • 如果此时该索引位置为红黑树结构，就新添加一个树节点。

在这里插入图片描述

  • 链表结构，无限循环此索引位置的链表。(e = p.next) == null 表示链表的最后一个元素，找到这个元素后，p.next = newNode(hash, key, value, null);指向新添加的链表node节点。此时还会进行一个是否需要树化的判断，最后跳出这个for循环。树化条件：binCount >= TREEIFY_THRESHOLD - 1，但是不一定转成红黑树（树化需要保证链表长度大于8&&数组长度达到64，如果不符合，则会resize()扩容）

在这里插入图片描述
链表判断这一段逻辑和上面一样，新添加的元素的key的hash值和此链表的某一个节点的key进行一个相等判断。则Node<K,V> e = p。
在这里插入图片描述
map中已经存在相同的key，再次添加此key，新的value值替换旧的value值，返回oldValue。
在这里插入图片描述

这是一个是否需要扩容的判断，如果当前map的k-v键值对数量>阈值threshold,则调用resize方法扩容。
在这里插入图片描述
扩容resize
1.扩容后的索引位置计算int index = hash(key)&(n-1)
假设扩容前数组的长度为16，key的hash二进制值为 1100 1100 1100 1100 1001 1011 0011 0101
在这里插入图片描述
假设扩容是按照2倍扩容的（后面源码会分析，先假装不知道，假设扩容后的容量是老容量*2）

在这里插入图片描述 得出结论：

  • 用两个不同的hash值和扩容后的数组长度的hash值进行&运算，键key的hash值对应的高位2进制无论是0还是1，&最终都是0，所以最终扩容后，重新计算索引位置，某key在新数组的index要么等于之前老数组的索引，要么为oldIndx+扩容的量，比如上面例子中的5+16=21。

看下扩容resize()方法：

  final HashMap.Node<K,V>[] resize() {
        //todo  oldTab 旧的数组,假设旧数组长度为16
        HashMap.Node<K,V>[] oldTab = table;
        //todo  判空 旧数组不为空，返回数组长度。
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // todo  旧的阈值   oldThr =16*0.75=12
        int oldThr = threshold;
        // todo  新数组长度 新阈值
        int newCap, newThr = 0;
        //todo 如果就数组长度大于0
        if (oldCap > 0) {
            // todo 如果旧数组长度大于最大容量2^30,threshold= Integer.MAX_VALUE,返回旧的数组。
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // todo 如果旧数组左移一位小于最大容量2^30成立，并且旧数组长度大于等于16
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                //todo  double threshold  oldThr << 1,即阈值乘以2,newThr=24;
                newThr = oldThr << 1;
        }
        //todo 走上面判断，就不会走这个判断了。
        else if (oldThr > 0)
            // initial capacity was placed in threshold
            newCap = oldThr;
        else {
          //  TODO 初始化map，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);
        }
        //todo 此时threshold==24
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        // todo 新数组诞生了
        HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
        // todo 旧数组变量指向新数组地址
        table = newTab;
        if (oldTab != null) {
            //todo 遍历老数组
            for (int j = 0; j < oldCap; ++j) {
                //todo 定义e变量,做过度用的
                HashMap.Node<K,V> e;
                //todo 如果oldTab[j]此位置取不到值，则不谈
                if ((e = oldTab[j]) != null) {
                    //todo 进来了,肯定就是oldTab[j]!=null,并将值赋给e变量
                    oldTab[j] = null;
                    //todo e.next == null，表示old数组此索引位置下就是一个元素，不是链表，也不是红黑树。
                    if (e.next == null)
                        //todo 直接放到新的数组中 e.hash & (newCap - 1)计算索引位置。
                        newTab[e.hash & (newCap - 1)] = e;
                        //todo 树结构 要把树结构拆分下来
                    else if (e instanceof HashMap.TreeNode)
                        ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else {
                        //todo 这里面就是链表的逻辑
                        HashMap.Node<K,V> loHead = null, loTail = null;
                        HashMap.Node<K,V> hiHead = null, hiTail = null;
                        HashMap.Node<K,V> next;
                        //todo do while 循环内主要是进行链表的元素头部和尾部的运算
                        do {
                          //todo next变量=链表e节点指向的下一个元素
                            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;
                            }
                        }
                       // todo next变量=链表e节点指向的下一个元素 直到为null 表示链表中所有的节点遍历结束 最后一个node节点next==null
                        while ((e = next) != null);
                        //  n=32           0000 0000 0000 0000 0000 0000 0010 0000  
                        //
                        //32-1           0000 0000 0000 0000 0000 0000 0001 1111
                        //            &
                        //key_hash       1100 1100 1100 1100 1001 1011 0010 0101
                        //===============================================================
                        //               0000 0000 0000 0000 0000 0000 0000 0101  =>index =5  
                        //todo hash值和old数组长度&运算，高位取0成立，表示e所在新的数组index下标==old index 下标
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        //  n=32           0000 0000 0000 0000 0000 0000 0010 0000  
                        //
                        //32-1           0000 0000 0000 0000 0000 0000 0001 1111
                        //            &
                        //key_hash       1100 1100 1100 1100 1001 1011 0011 0101
                        //===============================================================
                        //               0000 0000 0000 0000 0000 0000 0001 0101  =>index =21 
                        //todo old索引位置加上老数组的length,作为元素在新数组中的index下标。
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }
骑在自行车上的马云
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
集合框架系列 Map（十）：HashMap 1.8
windy杨树的博客
03-18 463
目录 1 概述 2 原理 3 源码分析 　3.1 构造方法 　　3.1.1 构造方法分析 　　3.1.2 初始容量、负载因子、阈值 　3.2 查找 　3.3 遍历 　3.4 插入 　　3.4.1 插入逻辑分析 　　3.4.2 扩容机制 　　3.4.3 链表树化、红黑树链化与拆分 　3.5 删除 　3.6 其他细节 　3.7 总结 1. 概述 本篇文章我们来聊聊大家日常开发中常用的一个集合...
HashMap源码解析
03-05 1386
HashMapt源码解析 1.HashMap介绍 HashMap作为Map的主要实现类，是存储K-V键值对的数据结构，可以存储null的key和value，底层用数组+链表+红黑树的存储，也叫哈希桶 HashMap是线程不安全的， 在jdk 1.8之前都是数组+链表的结构，在链表中的查询操作都是O(N)的时间复杂度 为了提高效率，1.8之后改为数组+链表+红黑树，当链表节点数量达到一定值，链表转换为红黑树结构，增删改查都是O(log n)。 HashMap存储过程： 当调用HashMap的构造函数，先对
Java基础笔记（2）——HashMap的源码，实现原理，底层结构是怎么样的
weixin_40689446的博客
09-10 539
Java基础笔记（2）——HashMap的源码，实现原理，底层结构是怎么样的 HashMap的源码，实现原理，底层结构 1、HashMap： HashMap是基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。 （除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。） 此类不保证映射的顺序，特别是它不保证该...
HashMap源码解析超详细
最新发布
weixin_43691942的博客
04-12 1374
HashMap源码解析超详细
HashMap 源码分析
12-22
《HashMap 源码解析——JDK11版本》 HashMap是Java中广泛使用的非同步散列表，其设计和实现是高效且灵活的。在JDK1.8之前，HashMap的底层数据结构采用的是数组+链表的方式，这种方式称为“拉链法”来解决哈希冲突。...
Java集合系列之HashMap源码分析
08-27
Java集合系列之HashMap源码分析 Java集合系列之HashMap源码分析是Java集合系列中的一篇非常重要的文章，它详细介绍了Java集合系列之HashMap源码，具有很高的参考价值。下面我们将对HashMap源码进行详细的分析。 ...
HashMap 源码详细分析(JDK1.8)
weixin_34178244的博客
01-22 610
1.概述 本篇文章我们来聊聊大家日常开发中常用的一个集合类 - HashMap。HashMap 最早出现在 JDK 1.2中，底层基于散列算法实现。HashMap 允许 null 键和 null 值，在计算哈键的哈希值时，null 键哈希值为 0。HashMap 并不保证键值对的顺序，这意味着在进行某些操作后，键值对的顺序可能会发生变化。...
【数据结构-源码分析】HashMap源码分析(超级详细）
fearless的博客
01-03 1141
HashMap基于哈希表的Map接口实现，是以key-value存储形式存在。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同)。在 JDK1.8 中，HashMap 是由数组 + 链表 + 红黑树构成，新增了红黑树作为底层数据结构，结构变得复杂了，但是效率也变的更高效。当一个值中要存储到Map的时候会根据Key的值来计算出他的hash，通过哈希来确认到数组的位置，如果发生哈希碰撞就以链表的形式存储。当链表长度过长时，HashMap会把这个链表转换成红黑树来存储。
最详细的Hashmap源码解析
qq_45830276的博客
09-08 1321
最详细的HashMap源码解析，从底层代码一步一步走进实现过程及其原理，非常实用。
HashMap是什么
weixin_43410352的博客
03-24 581
网上有篇博文总结得很好，始终贯彻避免重复造轮子，我就直接引用这篇博客了。。。。 原文地址：https://www.cnblogs.com/chengxiao/p/6059914.html 哈希表（hash table） 也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中HashMap的实...
HashMap 的 源码分析
Fearless____的博客
03-12 242
哈希表在JDK 8之前由数组和链表组成，JDK 8之后由数组、链表和红黑树组成我们先来简单了解下哈希表的原理，下图中有一个数组，数组元素是键值对（为了对接HashMap，哈希表不一定存储键值对，其实可以简单的理解为：存储键值对的哈希表就是HashMap），当一个键值对到来时（西瓜是键，10块是值），通过一个哈希函数，计算出键（西瓜）所对应的哈希值（为3），将该键值对存储在数组下标为3的位置，按此原理继续添加几个键值对。
HashMap的源码分析
leofee的博客
01-18 877
文章目录前言一、HashMap重要的几个属性二、HashMap源码分析1. HashMap的初始化2.HashMap容量为什么要设置为2的幂次方整数3. HashMap的哈希算法4. HashMap添加元素的过程5. HashMap的扩容机制JDK1.7 中HashMap添加元素导致死循环1.8 对HashMap的改进HashMap和HashTable的区别 前言 HashMap实现于Map接口，是一种存储key-value对的容器。 底层数据结构为哈希表，数组，链表，红黑树（当链表的长度大于等8时，链表
HashMap源码分析(一):JDK源码分析系列
chuzhengku0968的博客
07-11 316
> 正文开始 注:JDK版本为1.8<br> HashMap1.8和1.8之前的源码差别很大 目录 简介 数据结构 类结构 属性 构造方法 增加 删除 修改 总结 1.HashMap简介 HashMap基于哈希表的Map接口实现，是以key-value存储...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值