Java HashMap源码阅读

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量103 收藏
点赞数
分类专栏： java 文章标签： java hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anying5823/article/details/104940982
版权

HashMap

HashMap的默认属性

//table默认初始化容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//table最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//加载因子，HashMap在其容量自动增加前可达到多满的尺度
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//table的树化阈值，即链表转成红黑树的阈值，在存储数据时，当链表长度大于该值时，将链表转换成红黑树
static final int TREEIFY_THRESHOLD = 8;
//table的链表还原阈值，当红黑树转为链表的阈值，当在扩容时，此时HashMap的数据存储位置
//会重新计算，在重新计算位置后，当原有的红黑树内数量<6时，则将红黑树转化为链表
static final int UNTREEIFY_THRESHOLD = 6;
//最小树形化容量阈值，当table的容量大于该值是，才允许树形化链表，将链表转换为红黑树
//否则，若桶内元素太多时，直接扩容，不进行树形化
//为了避免扩容，树形化选择的冲突，这个值不能小于4 * TREEIFY_THRESHOLD。
static final int MIN_TREEIFY_CAPACITY = 64;

HashMap的构造函数

HashMap共有四个构造函数

//传入参数为初始容量和加载因子。
public HashMap(int initialCapacity, float 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);
}
//传入初始容量（使用默认的加载因子0.75）
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//均使用默认参数
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//使用传入的HashMap的参数
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    //计算大于m.size()/factory的最小的二次幂
    putMapEntries(m, false);
}

put方法

put方法首先计算传入的key，在调用putval方法，计算hash时对哈希码进行二次处理。

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
    //tab用于记录当前的存储table
    Node<K,V>[] tab;
    //p记录当前hash所指向的table中的节点的信息。
    Node<K,V> p;
    //n记录table的长度，i记录当前hash所指向的下标。
    int n, i;
    //判断table是否为null，长度是否为0，如果这两个有一个满足，则说明当前table没有初始化，于是重新初始化
    if ((tab = table) == null || (n = tab.length) == 0)
    //若需要初始话，记录初化后n的长度
        n = (tab = resize()).length;
    //查看当前table中hash指向的值是否为空
    if ((p = tab[i = (n - 1) & hash]) == null)
    //如果为空，则直接将传入的值插入
        tab[i] = newNode(hash, key, value, null);
    //如果不为空，则再次分情况
    else {
        //进入这个条件说明tab[i]不为空
        Node<K,V> e; K k;
        //该条件判断出是否输入的key与当前存储的key相同，则直接将e赋值为p
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //如果当前table[i]中保存的节点与p不相同，
        //那么说明table[i]中保存的是链表或者红黑树
        //如果p是红黑树的一个节点
        else if (p instanceof TreeNode)
            //将传入的节点存放进树结构中，
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        //如果不是红黑树节点，则说明p是链表
        else {
        //进入该条件说明p中存放的是链表
        //遍历该链表
            for (int binCount = 0; ; ++binCount) {
                //如果链表的下一个节点为kong，则说明链表中没有与传入节点相同的节点
                if ((e = p.next) == null) {
                    //将新节点插入链表的尾部
                    p.next = newNode(hash, key, value, null);
                    //插入节点之后判断是否需要树形化链表
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //如果在链表中找到了与新插入节点相同的key值的节点，
                //就直接在e中存放该节点。
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                p = e;
            }
        }
        //到这一步之后，e中存放的就是即将插入value值的节点。
        //如果e为null则不插入，如果e不为bull，则按照条件进行插入。
        if (e != null) { // existing mapping for key
            V oldValue = e.value;
            if (!onlyIfAbsent || oldValue == null)
                e.value = value;
            afterNodeAccess(e);
            return oldValue;
        }
    }
    ++modCount;
    //如果执行插入节点后该HashMap中存放的节点数量大于threshold，那么就进行resize操作
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

HashMap table的扩容

在插入数据周，如果发现HashMap中存放的节点数量大于threshold，就会执行扩容操作，threshold为加载因子乘上当前容量。只有数组的容量大于设置的MIN_TREEIFY_CAPACITY时，才会将数组中存储链表转化为红黑树结构。

final Node<K,V>[] resize() {
    //记录当前ildTab记录未扩容前的table
    Node<K,V>[] oldTab = table;
    //如果table没有初始化，oldCap赋值为0，
    //如果table已经初始化了，table赋值当前table的长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    //threshold为一个阈值，当HashMap中的容量大于这个阈值时，
    //执行resize()操作，在table未初始化时值为0
    //oldThr为记录resize之前的threshold
    int oldThr = threshold;
    int newCap, newThr = 0;
    //如果是初始化阶段，不进入这个if，非初始化阶段进入这个if
    if (oldCap > 0) {
        //如果当前table容量比设定的最大的容量还要大，
        //就只将threshold设定为Integer.MAX_VALUE
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //否则，将新容量设定为当前容量的两倍，而且当前容量大于等于默认的容量，
        //就将新的阈值也设定为旧阈值的两倍
        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 {               // zero initial threshold signifies using defaults
    //将新容量设置为默认的容量，新的阈值设定为默认容量乘0.75
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    //默认情况下不会进入这个if
    if (newThr == 0) {
        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
    table = newTab;
    //给新table赋值，如果是初始化，则跳过
    if (oldTab != null) {
        //遍历旧数组
        for (int j = 0; j < oldCap; ++j) {
            //e记录旧数组的数组中存放的链表头或数根节点
            Node<K,V> e;
            //如果数组中存放的节点不是null
            if ((e = oldTab[j]) != null) {
                //将就数组的该为清0
                oldTab[j] = null;
                //如果e只有一个值，没有形成链表
                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 { // preserve order
                //如果table[j]中存放的是链表
                    //loHead和hiHead将原链表拆成两个链表保存
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        //数组扩容后如果链表中保存的Node与数组容量的按位与为0，
                        //那么将将该Node放到loTail中
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        //如果为1，则放置hiHead中
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    //将loHead链表放到数组原下标位置上
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                    //将hiHead链表放到j+oldCap位置上。
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

HashMap查询数据

首先计算传入key值的hash值，之后调用getNode方法

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用于存储table中保存到额节点
        (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)
            //如果table该下标中保存的红黑树，则执行红黑树的方法
                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;
}

HashMap 删除节点

//输入参数（key的hash，key，null，false，true）
final Node<K,V> removeNode(int hash, Object key, Object value,
                            boolean matchValue, boolean movable) {
    //tab用于保存当前table，n保存当前table的长度，
    //p用于保存传入的key的hash值映射再table中的位置
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    //如果key不为空
    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;
    //如果key相同，则说明数组中该index存放就是该节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        //如果不相同，则说明数组中存放的是链表或者红黑树
        else if ((e = p.next) != null) {
            //如果p是红黑树
            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;
}

HashMap树形化节点

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    //当table的大小大于等于MIN_TREEIFY_CAPACITY时，
    //才可以将链表树形化为红黑树，否则直接执行扩容操作
    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);
    }
}
mu6y
关注
专栏目录
Java中的HashMap源码分析
Palpitate_fx的博客
03-27 997
目录 HashMap的继承体系 什么是Map 哈希表 存储结构 HashMap的属性 Node内部类 HashMap的构造方法 数组容量的计算 put( K key,V value)方法 HashMap的扩容机制 HashMap新的数组的填充 HashMap的get操作 HashMap 中的红黑树 散列冲突解决方式 HashMap的继承体系 1.HashMap实现了Serializable接口，可以被序列化 2.HashMap实现了Cloneable接口，可..
java7hashmap源码-java:Java
06-04
hashmap源码 Table Of Contents day01_JAVA语言概述与基本语法：标识符、变量也变量分类、源码_反码_补码、进制转换、编码与字符集 day02_基本语法.运算符：算术运算符、赋值运算符、比较运算符、逻辑运算符、位...
Java-HashMap源码
ALONG的博客
02-26 709
简介   HashMap 主要用来存放键值对，它基于哈希表的 Map 接口实现，是常用的 Java 集合之一，是非线程安全的。   HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个。   JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。    JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（
java HashMap 源码分析（深度讲解）
Cyan_RA9的博客
03-27 1702
java 集合篇章——HashMap源码分析（非常详细）。
JAVA HashMap源码阅读笔记
qq_26496093的博客
08-23 195
JAVA HashMap源码阅读笔记 默认参数设置 //如果构造函数初始化没有传值。则使用默认的初始化哈希桶容量为16 , static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 //最大hash桶容量 static final int MAXIMUM_CAPACITY = 1 << 30; //默认加载因子 static final float DEFAULT_LOAD_FACTOR = 0.75f; //
Java HashMap 源码分析
BusyMonkey
07-17 1012
https://www.cnblogs.com/chengxiao/p/6059914.html   哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑。本文会对java集合框架中的对应实现HashMap的实现原...
【Java】JDK1.8 HashMap源码，put源码详细讲解
qq_61024956的博客
05-02 4229
在Java中，HashMap结构是被经常使用的，在面试当中也是经常会被问到的。这篇文章我给大家分享一下我对于HashMap结构源码的理解。HashMap的存储与一般的数组不同，HashMap的每一个元素存储的并不是一个值，而是一个引用类型的Node结点，这也就意味着这个Node结点有被扩充的可能，因为这个Node结点可以是一个链表的Head结点，也可以是一棵树的根节点。HashMap的存储数组叫做也可以称作。
深入解析Java HashMap的Resize源码
Java领域优秀创作者
06-05 1196
通过对HashMap的resize()方法的详细分析，我们可以看到其设计的精妙之处。在扩容过程中，既考虑了性能优化，又保证了数据的正确性。整个过程分为计算新容量和阈值、创建新数组、迁移旧元素三个主要步骤。每一步都精确地考虑了各种可能的情况，使得HashMap在面对不同负载和容量需求时能够高效运作。HashMap作为Java中一个重要的数据结构，其内部实现充分展示了数据结构与算法的巧妙结合。理解其扩容机制，对于我们在实际应用中优化性能、合理使用内存具有重要意义。
java hashmap源代码了解
qq_28648047的博客
10-25 162
昨天面试官问我  用java实现hashmap 我直接蒙蔽了，所以回来看了看hashmap是个什么东西？ via:什么是哈希表和哈希算法？ 比如这里有一万首歌，给你一首新的歌X，要求你确认这首歌是否在那一万首歌之内。 无疑，将一万首歌一个一个比对非常慢。但如果存在一种方式，能将一万首歌的每首数据浓缩到一个数字（称为哈希码）中，于是得到一万个数字，那么用同样的算法计算新的
【java基础】HashMap源码解析
秃头披风侠的博客
03-11 1450
HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。 HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。 HashMap 是无序的，即不会记录插入的顺序。 HashMap 继承于AbstractMap，实现 HashMap使用K-V的形式存储数据，Map的扩容机制是按照2倍进行的，当达到阈值时就会扩容。当hash冲突严重时，链表会转换为红黑树，当树元素个数很少时，又会退化为链表。
java HashMap添加数据
zmd9999的博客
07-30 167
如果插入的数据存在，返回原有的数据，并用新的value，更新旧的value。插入存在的数据时，是否会用新value替换旧value。如果插入的数据不存在，插入成功，返回null。如果插入的数据不存在，插入成功，返回null。put会，putIfAbsent不会。如果插入的数据存在，返回原有的数据。源代码：（jdk 1.8.0）源代码：（jdk1.8.0）源码：（jdk 1.8.0）
Java8 HashMap源码的简单分析（1）
12-22
首先在阅读HashMap源码前，我们需要知道的： 一.数组：连续的存储结构，存储相同类型的数据。对于指定下标的查找，时间复杂度为o(1)；对于定值的查找，需要遍历数组，时 间复杂度为o(n)，对于有序数组，则可采用二...
java7hashmap源码-JAVA-:JAVA-
06-04
hashmap源码 Notes 原理 basic 1 数据结构中各种东西的数量很很重要！！！可以考虑在在数据结构中定义一下 2 Java hashtable的contains用来查找是否存在value，和containsValue类似 查找key使用containskey方法， 3 ...
在Java8与Java7中HashMap源码实现的对比
08-31
总结，Java 8的HashMap源码实现通过引入红黑树优化了高负载情况下的性能，降低了哈希冲突的影响，而Java 7则相对简单，适合小规模数据存储。在实际应用中，应根据数据量和性能需求选择合适的版本。对于开发者来说，...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 643
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 788
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 264
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
Qt自定义控件：汽车速度表
weixin_44788175的博客
11-02 406
从外到内进行绘制，初始化画布，画渐变色外圈，画刻度，写刻度文字，画指针，画扇形，画内圈渐变色，画黑色内圈，写当前值。这里难点使用正弦和余弦计算绘制刻度字。
GEMM优化（待更新）
qq_62704693的博客
11-03 752
来源参考：深入浅出GPU优化系列：GEMM优化（一） - 知乎深入浅出GPU优化系列：GEMM优化（二） - 知乎深入浅出GPU优化系列：GEMM优化（三） - 知乎。
深入解析Java HashMap源码
"深入解析Java HashMap源码，理解其桶结构与节点实现" HashMap是Java编程中常用的数据结构，主要用于存储键值对。它基于哈希表实现，提供快速的查找、插入和删除操作。本文将从多角度解析HashMap的源码，帮助读者...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值