HashMap源码总结（持续更新中）

最新推荐文章于 2024-04-23 14:24:28 发布
最新推荐文章于 2024-04-23 14:24:28 发布
阅读量198 收藏
点赞数
分类专栏： java 文章标签： java hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37549050/article/details/104844482
版权
  1. 可以存放多少个数据： 
    源码：MAXIMUM_CAPACITY = 1 << 30 2的29次方
  2. 初始状态数组的大小： 
    源码static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
为什么是16呢，其实没有特别的含义。这个是一个经验数字，只要是2的倍数都行
  3. 负载系数： 
    final float loadFactor = DEFAULT_LOAD_FACTOR //0.74
这个数字和泊松分布相关
    DEFAULT_LOAD_FACTOR
  4. put方法 
    //常常被问到的问题：key = null的时候，hash(key)返回的是0，也就是说key= null的时候，node节点一定在0号链表的某个位置
 final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
        Node<K,V>[] tab; 
        Node<K,V> p; int n, i;
        //ps1 第一次put的时候，table为空，所以会初始化node数组
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //ps2 说明任何一个node在数组的哪个链表上面是使用自己key的hash来定位。发现这个角标没有链表，那么就他就是插入该位置的第一个node。直接二话不说插入就行了
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            //发现第一个位置里面有node值了，那么开始检查key是否存在
            Node<K,V> e; K k;
            //为什么要比较hash值？因为hash值比较的非常快，hash值是int类型
            //只有hash值比较通过之后，再进行内存地址或者具体对象内容值比较
            if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;   //key值已经存在，那么在下面代码就会把value替换一次，不管有没有值变化
            else if (p instanceof TreeNode)//转到树的逻辑处理
//根据泊松分布，在负载因子默认为0.75的时候，单个hash槽内元素个数为8的概率小于百万分之一，所以将7//作为一个分水岭，等于7的时候不转换，大于等于8的时候才进行转换，小于等于6的时候就化为链表。
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //按照ps2 位置代码可知，当前要put的内容一定在这表链表上面，代码里面使用了：p 表示
                //开始从数组上的这条链表上节点遍历
                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 不论如何，更新一下value值
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

     

  5. jdk1.8 链表变成红黑树的两个条件：数组长度大于64（小于的时候会触发resize,resize之后单链长度会小于8），需要转换的链表的长度节点数量大于等于8。

  6. jdk1.8的触发扩容有两个事件：1.整个大小大于了阈值，2.在触发树化的时候，数组长度小于64.

  7. get方法
final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> 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) {
                if (first instanceof TreeNode)//发现是树，给树处理
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {//普通链表，继续遍历该链表，直到最后链表末尾
                    if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

6.resize方法

//jdk1.8和jdk1.7的有很大区别
//jdk1.7只是简单的把old数组全部遍历，每条链条重新遍历，然后每个node重新计算在新数组中的位置。
//jdk1.7扩容的时候，当老数据插入到新的数组中的时候，都是直接插入到链条的第一个位置，所以会出现链条翻转的情况
//jdk1.8是一次性先放到一条链条上面，然后把链条放到数组上。jdk1.7是直接把数据放到对应数组链条的第一个位置
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //老数组的大小
        int oldThr = threshold;//老数组的扩容阈值，比如16*.075=12。如果调用的是new HashMap();那么threshold = 0；
        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)
                //注意if里面进行了逻辑操作。这个就是普通扩容操作，新的长度是旧的2倍
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold ps1
            newCap = oldThr;
        else { // zero initial threshold signifies using defaults，new hashmap时候执行的逻辑
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }

        if (newThr == 0) {
            //对于 ps1出代码，对新的数组阈值进行重新计算
            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;//让gc回事内存
                    if (e.next == null)//如果该链条只有一个node,那么就直接定位了，然后存入新数组中
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)//如果该链条是二叉树
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order 开始重新定位
                        //下面定位有很多数学相关的知识；
                        //原理：2倍扩容之后，如果(e.hash & oldCap) == 0，说明该node在新的数组中，所处数组的脚标不会变化
                        //原理：2倍扩容之后，如果(e.hash & oldCap) ！= 0，说明该node在新数组中，它的角标一定在：老角标+老数组长度  这个位置
                        Node<K,V> loHead = null, loTail = null;//用来处理数组位置不会发生变化的node。loHead储存的是处理完成的数据，LoTail可以看成是临时变量
                        Node<K,V> hiHead = null, hiTail = null;//用来处理数组位置会发生变化的node。HiHead储存的是处理完成的数据，HiTail可以看成是临时变量
                        Node<K,V> next;
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {//数组位置不会变，下面代码有点抽象，需要好好理解。下面实现了：把符合条件的node依次链接到lohead的屁股后面，所以jdk1.8是“不会发生颠倒的，仅限于在新数组角标不变的情况下”。当doWhile结束的时候，loHead的屁股后面最后一个node.next是脏数据，要进行处理
                                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);
                        //屁股后面的最后一个node的next是脏数据，如果不是脏数据，说明代码也就初问题了
                        if (loTail != null) {
                            //这里面是位置不会发生变化的node链条集合
                            loTail.next = null;//把链表放到数据里面
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            //这里面是位置发生了变化，变成了j+oldCap的链条集合。
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;

6.remove相关的方法

//调用remove的时候，参数中的value matchvalue movable一般是传入了默认的  
final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        //先找到链条
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            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<K,V>)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);
                }
            }
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)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;
    }

 

jdk1.7在插入数据的时候，是直接把数据插入到链表的表头。jdk1.8之后是插入到链表的表尾。

 

 

大仕忆
关注
专栏目录
HashMap源码总结
qq_17164811的博客
05-27 289
1、底层结构是 数组 + 单向链表 + 红黑树 （jdk8之后），之前是数组 + 链表 底层是，用node节点组成的数组 2、基于<key, value>对存储数据，数据会被封装成一个Node<K,V>节点，会存放它的hash值、key值、value值、next指针。 3、几个关键参数 初始容量 默认加载因子是0.75； 扩容临界值（容量*加载因子）; 这个东西不只是干了这个事，还有另一个作用 在使用构造函数创建hashmap时，如果指定了容量，那构造函
HashMap源码解析（体系化总结）持续更新
simonGeek的专栏
02-17 232
Java集合继承关系 典型集合源码阅读 HashTable 继承Dictionary类，实现Map类 使用Syncronize实现线程安全，读写都做 数组+单向链表存储 key的寻址算法：(hash & 0x7FFFFFFF) % tab.length; 32位 containsValue：两层遍历，外层遍历数组，内层单...
HashMap源码深度解析
克里斯的一小步
01-16 1万+
这里新增加节点采用了头插法，新节点都增加到头部，新节点的next指向老节点 这里涉及到了HashMap的扩容问题，随着HashMap中元素的数量越来越多，发生碰撞的概率就越来越大，所产生的链表长度就会越来越长，这样势必会影响HashMap的速度，为了保证HashMap的效率，系统必须要在某个临界点进行扩容处理。该临界点在当HashMap中元素的数量等于table数组长度*加载因子。但是扩容是一个非常耗时的过程，因为它需要重新计算这些数据在新table数组中的位置并进行复制处理。
HashMap 源码总结
weixin_51291483的博客
10-21 135
1.运算规则 2.哈希值 哈希值: 通过一定的散列算法,把一个不固定长度的输入,转成一个固定长度的输出,输出的结果集map中,hash就是一个int值 哈希表: 存储哈希值的数组 – 存取散列值(哈希值)的一个容器 ​ 哈希值到底如何存,该如何取呢??? --通过数组的角标实现数据的存取 ​ 需要一个映射: 不同的hash值存在对应角标位 hash值 – 运算–>index 哈希函数: 将哈希表通过某种运算规则得到对应index 如何让存取效率是最高的???
HashMap源码学习总结
李智正在学习的博客
12-25 542
什么是Map?Map用于保存具有key-value映射关系的数据首先看图！可以看出Java 中有四种常见的Map实现——HashMap, TreeMap, Hashtable和LinkedHashMap：·HashMap就是一张hash表，键和值都没有排序。 ·TreeMap以红黑树结构为基础，键值可以设置按某种顺序排列。 ·LinkedHashMap保存了插入时的顺序。 ·Hashtable
HashMap源码分析总结
lf1013667686的博客
01-06 421
HashMap源码剖析 源码jdk版本使用:1.8 了解HashMap的朋友都会知道其数据结构是数据和链表，可能再接着深聊就无从下手，今天带着各位深入研究HashMap源码。 (转发请声明) action 在代码开始之前，我们先熟悉一些变量和内部类相关的内容 //default_initial_capacity指该容器的默认容量是16 //1&lt;&lt;4比直接写16效率高。 stat...
HashMap源码
weixin_43415481的博客
03-15 505
JAVA后端开发知识总结（持续更新…） HashMap源码分析 文章目录HashMap源码分析一、HashMap概述1.1 HashMap的基本结构与属性二、JDK 1.7和1.8中的HashMap区别 一、HashMap概述 1.1 HashMap的基本结构与属性   HashMap 的底层是个 Node 数组（Node<K,V>[] table，继承Entry），在数组的每个索引位置（本身也会存储一个K-V键值对），如果存在多个节点，则是以链表或红黑树的形式存在。Node数组是在第一.
HashMap实现原理及源码分析
最新发布
2401_83916030的博客
04-23 415
四、五、一、什么是哈希表在讨论哈希表之前，我们先大概了解下其他数据结构在新增，查找等基础操作执行性能数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)
java HashMap理论总结
许诗宇的博客
01-12 396
注意：本文参考docs/java/collection/java集合框架基础知识&面试题总结.md · SnailClimb/JavaGuide - Gitee.com HashMap HashMap 和 Hashtable 的区别 1 线程是否安全：HashMap是非线程安全的，Hashtable是线程安全的,因为Hashtable内部的方法基本都经过synchronized修饰。（如果你要保证线程安全的话就使用ConcurrentHashMap吧！）； 2 效率：因...
Java面试复习体系总结（2021版,持续更新）
热门推荐
Viper的程序员修炼手册
02-26 11万+
Java面试复习体系总结（2021版） 一、Java基础 内容 Java基础（一）：Java集合框架（超详细解析，看完面试不再怕） Java基础（二）：迭代器（Iterator）（含使用方法详解） Java基础 （三）：LinkedList（含使用方法详解） Java基础（四）：ArrayList（含使用方法详解） Java基础（五）：HashSet（使用方法详解） Java基础（六）：HashMap（使用方法详解） Java基础（七）：栈 Stack（使用方法详解）
HashMap源码解析理解与总结
0老船长0的博客
08-20 214
本文章包含个人理解与参考文章部分内容，参考文章链接如下，侵权请联系我删除，谢谢 参考文章 其次，由于自始至终搞不定csdn这玩意的排版，所以排版很有问题，分享有道云笔记的内容 链接地址 HashMap在JDK1.8结构上为数组+链表+红黑树；JDK1.8之前都为数组+链表结构； 链表的查询操作都是O(N)的时间复杂度； 红黑树结构中，增删改查都是O(log n) 因此，HashMap中数组ta...
最详细的Hashmap源码解析
qq_45830276的博客
09-08 1759
最详细的HashMap源码解析，从底层代码一步一步走进实现过程及其原理，非常实用。
HashMap源码分析
学渣的博客
08-12 308
HashMap概述（非线程安全） HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。 线程安全的HashMap： 方法一：通过Collections.synchronizedMap()返回一个新的Map，这个新的map就是线程安全的。 这个要求大家习惯基于接口编程，因为...
JDK源码解析之HashMap类
Just Do IT
05-04 373
以下解析基于JDK8.0 HashMap的继承关系如下所示： public class HashMap extends AbstractMap implements Map, Cloneable, Serializable {Map是一个顶级接口，跟Collection接口并没有什么关系。HashMap的默认容量是16(1 final int hash; //存储key的has
HashMap实现原理分析
冷血之心的博客
04-07 6389
之前转载过一篇HashMap相关分析文章，快速链接：HashMap实现原理分析 既然有前辈已经将源码分析总结了出来，我们在继续学习研究源码实现的时候不妨借鉴借鉴前人的总结与经验~ 本文转自：https://blog.csdn.net/hefenglian/article/details/79763634 深度好文，先转载过来，慢慢研究。 目录 一、底层数据结构 二、HashMap...
HashMap源码分析(二)
qq_51510549的博客
02-15 518
一、HashMap的get()方法: 二、HashMap的remove()方法:
HashMap是什么
weixin_43410352的博客
03-24 603
网上有篇博文总结得很好，始终贯彻避免重复造轮子，我就直接引用这篇博客了。。。。 原文地址：https://www.cnblogs.com/chengxiao/p/6059914.html 哈希表（hash table） 也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中HashMap的实...
HashMap源码浅析
java_t_t的博客
07-27 178
HashMap底层结构： 数组+链表（或红黑树） Node<K,V>[] tab 1.put 1.计算key的hash值 2.如果HashMap中的数组为空，或者长度为0，先扩容 3.通过 (<数组长度> - 1 ) & hash 计算出当前元素下标，如果没有碰撞，直接将kv添加到数组中 4.处理hash碰撞（准确的说是下标碰撞）的情况 4.1.key相同时，需要更新，放到后面统一处理（hash相同，key不一定相同；key相同，hash一定相同） .
（Java）笔记篇---HashMap底层原理解析及HashMap常考面试题
X_H学Java的博客
12-26 1103
HashMap底层原理分析，对初始容量，哈希函数，常用方法，扩容方式等进行解析 HashMap常考面试题 为什么重写hashcode与equals方法
深入解析Java HashMap源码
当HashMap中的元素数量达到容量*负载因子时，HashMap会进行扩容，将原数组的大小翻倍，并重新计算所有元素的新桶位置。这个过程虽然消耗资源，但它保证了哈希表的负载均衡，避免了过多的碰撞。 插入操作（put()）在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值