HashMap 随记

已于 2024-05-31 10:41:48 修改
阅读量282 收藏 6
点赞数 4
分类专栏： Java 随记 文章标签： java
于 2024-05-30 16:54:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40228484/article/details/139328651
版权

HashMap 构造器


HashMap 共有四个构造器：

public HashMap(int initialCapacity, float loadFactor) {
    // 对于传入的初始容量（loadFactor） 及 负载因子（loadFactor）的一些边界判断
    if (initialCapacity < 0) 
    	throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
    if (initialCapacity > MAXIMUM_CAPACITY) 
    	initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor)) 
    	throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
    // 设值
    this.loadFactor = loadFactor;
    // 返回给定目标容量的二次方大小
    this.threshold = tableSizeFor(initialCapacity);
}
// 调用了 HashMap(int initialCapacity, float loadFactor)，其中 loadFactor 取默认值 DEFAULT_LOAD_FACTOR
public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
// 容量及负载因子皆使用默认值
public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; }
// 调用 putMapEntries 将值存入当前 hashmap
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

在上面构造器中存在一个方法【tableSizeFor】，这个方法的作用是：返回给定目标容量的二次方大小。

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

换句话说，HashMap 的默认容量为16，而容量是以2的次方扩充的（即使是自定义传入，也一定会经过转换，如传入30，则返回32），一是为了提高性能使用足够大的数组，二是为了能使用位运算代替取模预算；

HashMap 的实现原理

数据存储方式示例图：
在这里插入图片描述

在 JDK1.8 中，HashMap采用【位桶（数组table）+链表+红黑树】实现，当链表长度超过阈值（8）时，将链表转换为红黑树（table长度大于等于64），这样大大减少了查找时间；链表长度大于8时转化为红黑树，小于6时转化为链表；

HashMap put 方法：

/**
 * Associates the specified value with the specified key in this map.
 * If the map previously contained a mapping for the key, the old
 * value is replaced.
 *
 * @param key key with which the specified value is to be associated
 * @param value value to be associated with the specified key
 * @return the previous value associated with <tt>key</tt>, or
 *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
 *         (A <tt>null</tt> return can also indicate that the map
 *         previously associated <tt>null</tt> with <tt>key</tt>.)
 */
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

其中 hash 方法：

// 计算 hash code
static final int hash(Object key) {
    int h;
    // key.hashCode 的调用方法：Object 中的原生方法 public native int hashCode();
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

重头戏，putVal 方法：

/**
 * Implements Map.put and related methods.
 *
 * @param hash hash for key
 * @param key the key
 * @param value the value to put
 * @param onlyIfAbsent if true, don't change existing value
 * @param evict if false, the table is in creation mode.
 * @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;
    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<K,V> e; K k;
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        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);
                    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
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

头大，分解来看：

总体结构：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    /**
     * tab 用于保存 table 引用
     * 1、若 tab 为 null 或者 tab 的长度为 0，则调用 resize 方法进行初始化或者扩容
     */
    if ((tab = table) == null || (n = tab.length) == 0)
        n = (tab = resize()).length;
     /**
     * 2、到了这一步，tab 一定存在
     * i = (n - 1) & hash 确定元素存放在 tab 中的下标，p = tab[i] 
     */
    // 2.1、若 p 为 null，表示当前 tab 的 i 位置空，则可以直接直接构建 Node 插入
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else { // 2.2、若 p 不为 null，表示 tab 的 i 位置已经有值，则继续进行内部判断
        Node<K,V> e; K k;
        // ... 后续单独理解
    }
     /**
     * modCount 自增，记录操作行为次数
     * 3、++size > threshold，即判断下一次增加一个结点后size是否大于最大容量，如果是，则进行一次扩容
     */
    ++modCount;
    if (++size > threshold)
        resize();
    // 插入成功时会调用的方法（默认实现为空）
    afterNodeInsertion(evict);
    return null;
}

从 1 ~ 3 共三个步骤中，理解 putVal 方法大的执行方向。其中最复杂的是 2.2 中 else 中 的内容：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
    Node<K,V>[] tab; Node<K,V> p; int n, i;
    // ...
    else {
        Node<K,V> e; K k;
        // 已知：p = tab[i]，是 tab[i] 中链表或者红黑树第一个结点
        // 如果 p.hash 和 p.key 与传入参数中的 hash 和 key 相同，表示对应 key 已经存在，则直接使用原结点，只需要后面改变value即可
        if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        // 如果 p 是红黑树结点类型，则将其插入 tab[i] 位置中的红黑树中
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else { // p 是链表结点类型，则将其插入 tab[i] 位置中的链表中
            // 循环，尾插法
            for (int binCount = 0; ; ++binCount) {
                // 链表尾部
                if ((e = p.next) == null) {
                    // 构建新结点，并修改 p 的 next 指向
                    p.next = newNode(hash, key, value, null);
                    /**
                     * TREEIFY_THRESHOLD：将链表转换为红黑树的阈值（默认为8），超过该阈值执行 treeifyBin 方法
                     * 注意：执行 treeifyBin 方法并不代表一定会将链表转换为红黑树，它会根据 table 的总长度来决定，即：
                     * 只有当 table 的长度大于等于 64 后，才会执行转换红黑树操作，否则只会对 table 进行扩容
                     */
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // 这里会判断整条链表上的结点的key、Hash值与插入的元素的key、Hash值是否相等（前面只判断了链表中的第一个结点 p）
                // 如果相等，同前面一样，表示已经存在key值相同的结点【e = p.next，其中 e 已经赋值了】，则直接退出循环
                if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        if (e != null) {
            V oldValue = e.value;
            /**
            * public V put(K key, V value) {
            *     return putVal(hash(key), key, value, false, true);
            * }
            * 这里 onlyIfAbsent 为 false，则 !onlyIfAbsent 为 true，进而执行 e.value = value 【新值替换旧值】
            */
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            /**
             * 在HashMap中：void afterNodeAccess(Node<K,V> p) { }
             * 实际上，afterNodeAccess 是提供给LinkedHashMap类【继承HashMap】使用，LinkedHashMap 可以保证输入输出顺序的一致性
             * 类似的还有 afterNodeInsertion、afterNodeRemoval 这两个方法
             */
            afterNodeAccess(e); // 这里默认实现为空
            return oldValue;
        }
    }
    // ...
    return null;
}

putVal 方法中还涉及一些其他方法，如：

  1. resize：初始化或加倍表大小。如果 table 为空，则会根据字段阈值中保持的初始容量目标进行分配。
  2. treeifyBin：判断是否需要将链表替换为红黑树
    a. replacementTreeNode：将链表结点 Node 转换为树结点 TreeNode
    b. treeify：形成从该节点链接的节点的树
  3. Node：链表结点
  4. TreeNode：红黑树结点，关于红黑树的实现及对应操作，后续有机会再另讲

putVal 方法流程图（仅用于辅助理解源码）：
在这里插入图片描述

其他

关于其他的方法，如 get、entrySet、ketSet 等，都可以在理解上述代码后再去看源码即可

关于红黑树：需要首先理解红黑树概念，再回头来看这里的源码更有效果（TODO：红黑树及HashMap红黑树源码理解）

static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
    TreeNode<K,V> parent;  // red-black tree links
    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);
    }

    /**
     * Returns root of tree containing this node.
     */
    final TreeNode<K,V> root() {
        for (TreeNode<K,V> r = this, p;;) {
            if ((p = r.parent) == null)
                return r;
            r = p;
        }
    }
    // ...省略几百行
}

补充1：HashSet

HashSet 的底层实现是 HashMap，来看 HashSet 的无参构造器：

/**
 * Constructs a new, empty set; the backing <tt>HashMap</tt> instance has
 * default initial capacity (16) and load factor (0.75).
 */
public HashSet() {
    map = new HashMap<>();
}

add 方法：

public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

这里是把传入的值，作为 map 的 key 传入，而 value 统一为 PRESENT【private static final Object PRESENT = new Object();】

HashSet 之所以可以保证数据不会重复，其关键在于调用了 HashMap 的 put 方法：

// ...
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); // 通过hash计算【add】方法传入的e的下标i，若在table[i]不存在则构建结点保存
else {
    // 如果结点存在，则判断 key 与 hash 值是否都相同，具体流程此处不再赘述
    Node<K,V> e; K k;
    if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
        e = p;
    // ...
}
 // ...

也就是说，HashSet 利用 HashMap 中 key 值不能重复的特性来保证其存入的值不会重复。

HashSet 中其他方法基本都基于 HashMap 的方法，此处不再赘述。

-木云-
关注
  • 4
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hashMap.txt
08-16
haspMap介绍，与字符串中出现的字母和数字的次数。
hashMap1.8源码
01-19
主要hashMap源码，包括put，get等，其中将代码风格修改为更易懂的风格，注释也更简洁明了，可以帮助学习hashMap的同学更简单的学习hashMap
HashMap.zip
11-01
HashMap总结、面试资料！！（2020下半年） 包含：HashMap线程安全 + ConcurrentHashMap + HashMap + 源码分析 + jdk1.8的HashMap和ConcurrentHashMap。 欢迎下载学习
C语言实现hashMap
11-10
C语言实现hashMap，包含创建hashMap、插入hashMap、查找hashMap、删除hashMap，已经若干经典的hash函数。文章链接：https://blog.csdn.net/sxf1061700625/article/details/109594495
hashmap.zip
08-28
HashMap 1.7源码分析HashMap 1.7源码分析HashMap 1.7源码分析HashMap 1.7源码分析HashMap 1.7源码分析
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 720
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
Day43
m0_67496588的博客
06-20 985
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 199
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
Java面试八股之简述JVM内存结构
u012151345的博客
06-20 789
在Java 8之前，永久代（Permanent Generation）是方法区的实现，之后被元空间（Metaspace）取代。总结来说，JVM内存结构设计精巧，通过区分线程私有和共享区域，以及细致划分各个区域的功能，确保了Java程序的高效、安全运行。每个线程都有自己的栈，用于存储方法调用时的信息，包括局部变量表、操作数栈、动态链接、方法出口等。方法区的一部分，存放编译期生成的各种字面量和符号引用，如字符串字面量、类名、方法名等。JVM中最大的一块内存区域，用于存储几乎所有的对象实例和数组。
Rust高性能日志库tklog0.0.8—支持mod设置参数
donnie4w技术专栏
06-21 753
tklog是rust高性能结构化日志库，支持同步日志，异步日志，支持自定义日志的输出格式，支持按时间，按文件大小分割日志文件，支持日志文件压缩备份，支持官方日志库标准API，支持mod独立参数设置
Spring 事务传播行为之Propagation.NESTED REQUIRES_NEW等探讨
chengmin123456789的博客
06-17 237
当一个事务方法（标记为@Transactional(propagation = Propagation.NESTED))被另一个活动事务调用时，它会创建一个“保存点”（Savepoint）作为新的事务开始点。这意味着，如果这个嵌套事务方法内部发生异常并导致回滚，事务会回滚到这个保存点，而不会影响到外部事务的其他操作。如果一切正常，嵌套事务会在外部事务结束时一起提交。
Geoserver源码解读三 GeoServerBasePage
Yuanben_wuxin的博客
06-19 978
GeoServerBasePage 登录
探讨 MyBatis 特殊 SQL 执行技巧与注意事项
良月柒
06-18 650
/MyBatis 作为一个灵活的持久层框架，通过提供丰富的动态 SQL 标签、SQL 片段复用、存储过程调用、复杂结果集处理、分页查询和批量操作等功能，使开发者能够高效地实现各种复杂的 SQL 操作。
JVM 相关知识整理
杨杨杨~~的博客
06-20 704
如果您觉得有用的话，记得给，写作不易啊^ _ ^。而且听说，实在白嫖的话，那欢迎常来啊!!!
Java中的Continue语句及其示例
Muhtar_的博客
06-20 151
Continue语句主要用于循环内部。每当在循环中遇到它时，控件都会直接跳到循环的开头进行下一次迭代，跳过当前迭代中循环体中语句的执行。当您希望继续循环，但不希望循环体中的其余语句（在continue语句之后）为该特定迭代执行时，这一点尤其有用。和你在这里看到的一样。我们将计数器值从10迭代到0，当计数器值为7时，循环跳过print语句并开始while循环的下一次迭代。示例：在While循环中使用continue。do-Wile循环中continue的示例。Java中的Continue语句及其示例。
Java SE入门及基础（55）& Stream流及常用API
m0_63181360的博客
06-19 504
通过外部迭代，你的应用程序既可以确定要迭代的集合，又可以确定迭代的方式。它可以更轻松地利用并行计算的优势，这涉及将问题分为子问题，同时解决这些问题，然后将解决方案的结果组合到子问题中。）会产生非流结果，例如原始值（如双精度值），集合，或者在forEach的情况下根本没有任何值。它们处理流中的元素：聚合操作从流中而不是直接从集合中处理元素。流将一个基本数据类型的数组转换为包装类型的数组，再将包装类型的数组转换基本数据类型数组。筛选器操作返回一个新流，该流包含与筛选条件（此操作的参数）匹配的元素。
在阿里云服务器Linux系统上从头到尾实现Webapp的部署(安装卸载JDK、安装Tomcat、安装配置MySQL)
2401_85124218的博客
06-20 463
我可以将最近整理的前端面试题分享出来，其中包含HTML、CSS、JavaScript、服务端与网络、Vue、浏览器、数据结构与算法等等，还在持续整理更新中，希望大家都能找到心仪的工作。
高通Android 12/13 Launcher3修改RecentView与屏幕方向保持一致
qq_15950325的博客
06-18 393
最近同事遇到一个需求说，recentview应用预览与屏幕方向不一致，问题，于是加了一些日志，实现此需求。3、最后展示RecentView与屏幕方向保持一致。2、源码修改diff如下所示。源码修改路径汇总如下。
java-System 概述 2
weixin_41247813的博客
06-18 832
模块化和高内聚性是设计优良系统的重要原则。`System`类通过`setSecurityManager`和`getSecurityManager`方法允许设置和获取当前的安全管理器（Security Manager）。`System`类中的许多方法（例如`currentTimeMillis`和`arraycopy`）都是通过类似的机制实现的。- **使用`arraycopy`进行数组拷贝**：与手动循环相比，`System.arraycopy`方法在性能上更优，因为它是本地实现的，直接操作内存。
hashmap内容读入hashmap
11-21
根据提供的引用，可以了解到Map集合是一种键值对应的数据结构，而HashMap是Map集合的一种实现方式。在Java中，可以通过读取文件的方式将内容读入HashMap中。具体实现步骤如下： 1. 创建一个空的HashMap对象，用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值