HashMap源码分析（一）

news2025/1/23 10:21:14

存储结构

说明：本次讲解的HashMap是jdk1.8中的实现，其他版本可能有差异

内部是由Node节点数组组成，Node节点之间又由链表或红黑树组成。

图是网上找的，实在不想画

image.png

属性介绍

    //存储数据的数组，初次使用时初始化，分配的长度总是2的冥次方
    transient Node<K,V>[] table;

    /**
     * Holds cached entrySet(). Note that AbstractMap fields are used
     * for keySet() and values().
     */
    transient Set<Map.Entry<K,V>> entrySet;

    //容器中包含的所有元素数量
    transient int size;

	//代指HashMap结构被修改的次数，结构修改是指更改HashMap中映射的数量或以其他方式修改其内部结构的修改 
    transient int modCount;

    //下一次扩容的大小值 (capacity * load factor)
    int threshold;

    //扩容系数
    final float loadFactor;

构造方法

HashMap有4个构建方法，主要作用就是初始化存储数组容量、扩容系数、下一次触发扩容大小

public HashMap(int initialCapacity, float loadFactor) {
    	//初始容量，不能小于0，否则抛非法参数异常
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
    	//容器超限了，则默认设置为最大值，2^30次方
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
    	//扩容系数设置不对，也会抛出异常
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor; //设置扩容系数
        //根据设置的初始数组大小计算下次触发扩容时的大小，初始情况下threshold也表示数组的初始大小，这个可以通过resize()方法中看到
        this.threshold = tableSizeFor(initialCapacity);  
    }

    public HashMap(int initialCapacity) {
        //调用第一个构造方法，loadFactor默认0.75
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    public HashMap() {
        //只设置loadFactor，默认0.75，其他字段都默认值
        this.loadFactor = DEFAULT_LOAD_FACTOR; 
    }

    public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false); //创建新的hashmap，并把原来的m内容填充进去
    }

散列算法

static final int hash(Object key) {
    int h;
    //h >>> 16 hash值右移16位，实际上就是将高16位通过右移到低16位，然后通过与原hash值异或处理，使高16位也参与到索引数组位置的计算当中，这样做的好处是为了同时保留高16位于低16位的特征，让哈希后的结果更均匀的分布，减少hash冲突，提升hashmap的运行效率。
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

HashMap是根据hash值，通过以下方式计算存储的位置：(数组长度 - 1) & (h ^ (h >>> 16))

(n-1) & hash判断元素存放的位置，n等于数组的长度，与运算相当于取余运算(计算效率较取余运算更高)。假如不做 (h >>> 16) 右移运算，那么hash仅是最后四位和1111运算(假如数组长度为16)那么hash高位的信息就会全部丢失（比如，多个key的hashcode最后四位都是0000那么就会全部存储在索引为0的桶中产生冲突），如果右移16位就会将高位的信息与低位的16位异或运算，保留了高位与低位的特征更能体现key的hashcode的特征，降低冲突的概率。

put方法

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

/**
     * Implements Map.put and related methods.
     *
     * @param hash key的hash值
     * @param key the key
     * @param value 要存放的value
     * @param onlyIfAbsent如果为true，那么容器中如果存在就不改变已存在的值；否则替换
     * @param evict 意为逐出，在LinkedHashMap中有用，可以想像成LRU算法中对过期数据的删除
     * @return previous value, or null if none
     */
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    //初次进来table为空
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length; //通过resize()方法初始化table数组，并得到数组长度
    //(n - 1) & hash  根据hash取模求出在数组中的位置，并判断该位置是否已经有值，当前判断是无值状态
    if ((p = tab[i = (n - 1) & hash]) == null)
        //该索引位置没有值，那么创建新node，并赋值在该索引位置上
        tab[i] = newNode(hash, key, value, null);
    else {
        //走到这里，证明当前索引位置已经有冲突了
        Node<K,V> e; K k;
        //如果hash和key的值同时相等，那么就认为是同一个值，直接覆盖原来索引位置下的节点（value值的覆盖取决于onlyIfAbsent或者原node的value是Null）
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        else if (p instanceof TreeNode)
            //走到这里，证明冲突的节点不是完全相同的，并且原节点已经是（红黑）树化的节点了，那新节点肯定也应该是TreeNode
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //不是树，那就是链表，接下来执行链表的操作
            for (int binCount = 0; ; ++binCount) {
                //从链表头部开始遍历，一直到尾部，将新的node直接插入到尾部
                if ((e = p.next) == null) {
                    //尾部插入
                    p.next = newNode(hash, key, value, null);
                    //判断链表节点数是否大于等于TREEIFY_THRESHOLD（默认8），这里-1的原因，就是没算进新创建的节点，超过了，那么要（红黑）树化
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        //链表转红黑树，转换条件：1.链表节点数大于8；2.数组长度大于MIN_TREEIFY_CAPACITY（默认64）
                        treeifyBin(tab, hash); 
                    break;
                }
                //遍历链表的同时，判断有没有节点完全相同的，有的话，直接退出遍历
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) { // 存在相同的key
            V oldValue = e.value;
            //根据onlyIfAbsent的条件，判断是否覆盖原节点的值
            if (!onlyIfAbsent || oldValue == null)
                e.value = value; //覆盖原值
            afterNodeAccess(e); //这也是个钩子方法，hashmap中没有实现
            return oldValue; //返回原值
        }
    }
    //修改次数加1
    ++modCount;
    //size加1，并判断是否超过扩容触发条件，超过后重新扩容
    if (++size > threshold)
        resize(); //扩容
    //这是一个钩子方法，留待子类实现，比如在LinkedHashMap中就有使用
    afterNodeInsertion(evict);
    return null;
}
//树化方法
final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        //数组长度不足MIN_TREEIFY_CAPACITY（64）则不树化，只做扩容，避免数组节点都挤压（冲突）
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
            do {
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
                hd.treeify(tab);
        }
    }

get方法

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

/**
     * Implements Map.get and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
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) {
        //hash计算得到数组索引位置对应的节点，判断当前节点是否与要获取的hash和key一致，是的话，直接返回，不是继续往下走
        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;
}

remove方法

public V remove(Object key) {
    Node<K,V> e;
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}

   	/**
     * Implements Map.remove and related methods.
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to match if matchValue, else ignored
     * @param matchValue if true only remove if value is equal
     * @param movable if false do not move other nodes while removing
     * @return the node, or null if none
     */
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;
        //hash计算得到数组索引位置对应的节点，判断当前节点是否与要获取的hash和key一致，是的话，不用找了，已经找到了，并把node设置为当前找到的p，不是的话则继续往下走
        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)
                //红黑树节点，从树中删除，removeTreeNode方法针对节点数较少的情况，又会转会链表
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
            else if (node == p)
                //链表中第一个节点，直接移除，用next节点来填充
                tab[index] = node.next;
            else
                p.next = node.next; //找到的中间节点，则直接断链就行
            ++modCount; //增加修改次数
            --size; //大小减1
            afterNodeRemoval(node); //钩子方法
            return node;
        }
    }
    return null;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1190323.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Opencv for unity 下载

Opencv for unity 下载

GitHub - EnoxSoftware/VideoPlayerWithOpenCVForUnityExample: This example shows how to convert VideoPlayer texture to OpenCV Mat using AsyncGPUReadback. OpenCV for Unity | Integration | Unity Asset Store
阅读更多...
【原创】java+jsp+servlet简单图书管理系统设计与实现

【原创】java+jsp+servlet简单图书管理系统设计与实现

摘要&#xff1a; 图书管理系统是一个专门针对图书馆管理而设计的系统&#xff0c;它可以帮助图书管理员有效的对图书进行管理&#xff0c;在图书管理系统的设计中&#xff0c;首先要考虑的是系统的需求分析&#xff0c;该系统的设计与实现涉及多个方面&#xff0c;包括数据库…
阅读更多...
ubuntu系统黑屏，且光标不闪烁

ubuntu系统黑屏，且光标不闪烁

选择第二个&#xff0c;进入恢复模式 选择第二个&#xff0c;进入恢复模式 选择root 输入&#xff1a; startx然后就可以进入文本界面或者图形化界面了&#xff0c;如果不行&#xff0c;报错&#xff0c;可能需要需要下载这个包&#xff0c;把这个错误到网上搜索一下就可以找…
阅读更多...
【广州华锐互动】人造卫星VR互动科普软件带你探索宇宙世界

【广州华锐互动】人造卫星VR互动科普软件带你探索宇宙世界

在科学的广阔领域中&#xff0c;卫星科学和遥感技术占据了重要的位置。这些科学领域的进步&#xff0c;让我们有机会窥视宇宙的深处&#xff0c;揭示那些隐藏在星际之间的秘密。今天&#xff0c;我们要介绍一种新型的教学工具&#xff0c;即人造卫星VR互动科普软件&#xff0c;…
阅读更多...
【凡人修仙传】预计开播倒计时，线下举办超前观影活动，隆重期待

【凡人修仙传】预计开播倒计时，线下举办超前观影活动，隆重期待

Hello,小伙伴们&#xff0c;我是小郑继续为大家深度解析国漫资讯。 深度爆料凡人最新资讯&#xff0c;《凡人修仙传》这部备受期待的动漫作品&#xff0c;终于在新年之际宣布了定档日期。据悉&#xff0c;该动漫将于11月25日&#xff0c;也就是周六上午11点&#xff0c;与广大…
阅读更多...
GPT出现了Something went wrong.

GPT出现了Something went wrong.

网络上的一种说法如下
阅读更多...
限流式保护器在养老院火灾预防中的应用

限流式保护器在养老院火灾预防中的应用

安科瑞 华楠 【摘要】老年人是一个庞大特殊的社会群体。随着我国人口的老龄化&#xff0c;老年人口数量断上升。涉及老年人的火灾越来越多&#xff0c;本文从养老院火灾的案例、成因、预防措施等方面对此类火灾进行了深入的探讨。 【关键词】老年公寓&#xff1b;火灾预防&…
阅读更多...
对称二叉树（C++解法）

对称二叉树（C++解法）

题目 给你一个二叉树的根节点 root &#xff0c; 检查它是否轴对称。 示例 1&#xff1a; 输入&#xff1a;root [1,2,2,3,4,4,3] 输出&#xff1a;true示例 2&#xff1a; 输入&#xff1a;root [1,2,2,null,3,null,3] 输出&#xff1a;false C代码 #include <iostrea…
阅读更多...
使用bitmap实现可回收自增id

使用bitmap实现可回收自增id

需求描述 设计一个方法&#xff0c;每次调用返回一个自增id&#xff0c;同时需要满足以下要求。 可更新id的状态为已使用&#xff0c;已使用的id下次调用时不再返回可修改某个id的状态为未使用&#xff0c;下次调用时设为未使用状态的id可重新被返回 思路 思路一&#xff1…
阅读更多...
毅速丨为什么不锈钢材料在金属3D打印中应用广泛

毅速丨为什么不锈钢材料在金属3D打印中应用广泛

不锈钢材料作为一种常见材料&#xff0c;在金属3D打印中应用广泛&#xff0c;可以说是目前使用率最高的材料&#xff0c;为什么不锈钢大受欢迎&#xff0c;主要由几点原因。 第一、工艺适合性 金属3D打印的工艺&#xff0c;如直接金属激光烧结&#xff08;DMLS&#xff09;或选…
阅读更多...
spring boot+netty 搭建MQTT broken

spring boot+netty 搭建MQTT broken

一、项目结构 二、安装依赖 <!-- netty包 --><dependency><groupId>io.netty</groupId><artifactId>netty-all</artifactId><version>4.1.75.Final</version></dependency><!-- 常用JSON工具包 --><…
阅读更多...
双十一成交千万级！伊能静疗愈直播人-货-场洞察

双十一成交千万级！伊能静疗愈直播人-货-场洞察

近日&#xff0c;伊能静在小红书的疗愈直播火了。10月28日&#xff0c;小红书美护买手伊能静的第二场直播观看人数166万&#xff0c;粉丝人均观看时间12分52秒&#xff0c;11家在国内声量不大的国际品牌单品在直播间售罄。就此&#xff0c;也让我们看到了疗愈经济的可能性。 一…
阅读更多...
clang插件对llvm源码插桩，分析函数调用日志(2)--google镜像

clang插件对llvm源码插桩，分析函数调用日志(2)--google镜像

tick_plot__compile.ipynb clang插件对llvm源码插桩&#xff0c;分析函数调用日志(1) 分析 进出、链、出 df进出df[ df[tickKind].isin( [FuncEnter,FuncReturn] ) ]#代码中&#xff0c;只有在函数进入时&#xff0c;计算了链条长度 并写磁盘 df入df[ df[tickKind].isin…
阅读更多...
linux如何实现免密登录

linux如何实现免密登录

shigen日更文章的博客写手&#xff0c;擅长Java、python、vue、shell等编程语言和各种应用程序、脚本的开发。记录成长&#xff0c;分享认知&#xff0c;留住感动。 十一月是比较特殊的月份&#xff0c;因为很多云资源都是在这个时候过期&#xff0c;包括我自己买的云服务器。作…
阅读更多...
安装pr提示VCRUNTIME140.dll丢失的修复方法，3个有效的方法

安装pr提示VCRUNTIME140.dll丢失的修复方法，3个有效的方法

在学习和工作中&#xff0c;我们经常需要使用到PR和PS。然而&#xff0c;在安装这些软件时&#xff0c;有时会遇到一些错误提示&#xff0c;其中之一就是“VCRUNTIME140.dll丢失”&#xff0c;无法运行启动软件程序。那么&#xff0c;如何解决VCRUNTIME140.dll丢失的问题呢&…
阅读更多...
无人机航迹规划：七种智能优化算法（DBO、LO、SWO、COA、LSO、KOA、GRO）求解无人机路径规划--提供MATLAB代码

无人机航迹规划：七种智能优化算法（DBO、LO、SWO、COA、LSO、KOA、GRO）求解无人机路径规划--提供MATLAB代码

一、七种算法&#xff08;DBO、LO、SWO、COA、LSO、KOA、GRO&#xff09;简介 1、蜣螂优化算法DBO 蜣螂优化算法&#xff08;Dung beetle optimizer&#xff0c;DBO&#xff09;由Jiankai Xue和Bo Shen于2022年提出&#xff0c;该算法主要受蜣螂的滚球、跳舞、觅食、偷窃和繁…
阅读更多...
栈的顺序存储实现（C语言）(数据结构与算法）

栈的顺序存储实现（C语言）(数据结构与算法）

栈的顺序存储实现通常使用数组来完成。实现方法包括定义一个固定大小的数组&#xff0c;以及一个指向栈顶的指针。当元素入栈时&#xff0c;指针加一并将元素存储在相应位置&#xff1b;当元素出栈时&#xff0c;指针减一并返回相应位置的元素。 1. 顺序栈定义 #define MaxSi…
阅读更多...
C++ 之多态（一）

C++ 之多态（一）

什么是虚函数 在类的定义中&#xff0c;前面有 virtual 关键字的成员函数称为虚函数&#xff1b;virtual 关键字只用在类定义里的函数声明中&#xff0c;写函数体时不用。 class Base {virtual int Fun() ; // 虚函数 };int Base::Fun() // virtual 字段不用在函数体时定义 …
阅读更多...
python- os模块

python- os模块

一、文件与目录相关的操作 1、删除文件/文件夹 2、os.stat("path/filename"): 获取文件/目录信息的结构说明 3、os.listdir 和 os.path.join 在Python中&#xff0c;os.listdir()和os.path.join()是操作系统模块&#xff08;os模块&#xff09;的两个函数&#x…
阅读更多...
运维相关(一) - Vue项目配置WebSocket连接{ws、wss 连接方式}

运维相关(一) - Vue项目配置WebSocket连接{ws、wss 连接方式}

Vue项目配置WebSocket连接 ws、wss 两种方式 1. 写作背景2. 晒出代码2.1 前端 vue.config.js 的代码2.2 Vue项目路由配置代码3.3 服务器Nginx配置 3. 使用方式3.1 前端代码3.2 后端代码 4. 测试使用 1. 写作背景 项目使用的是ruoyi的前后端分离框架项目需要使用到 websocket , …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023