java---HashMap

于 2024-09-13 14:33:39 发布
阅读量512 收藏 7
点赞数 17
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44766305/article/details/142135685
版权

 HashMap是Map体系中最常用的一个集合。

 HashMap的特点

        1.HaspMap是Map里面的一个实现类。

        2.没有额外需要学习的特有方法,直接使用Map里面的方法

        3.特点都是由键决定:无序、不重复、无索引

        4.HaspMap跟HashSet底层原理一模一样,都是哈希表结构

HashMap底层原理

当创建一个Hash对象时，默认会创建一个长度为16，默认加载因子为0.75的数组。

nullnullnullnullnullnullnullnullnullnullnullnullnullnullnullnull
0  123456789101112131415

利用put方法就可以创建数据,put方法底层会创建一个Entry<V,V>对象,然后利用键去计算一个哈希值(这里使用键计算,跟值没有任何关系！！！！)

比如说:计算出来的值时5

nullnullnullnullnullvaluenullnullnullnullnullnullnullnullnullnull
0  123456789101112131415

 加入再put进来一个值，它计算的结果也是5：处理方式会有两种

        1.当计算出来的数组位置为null是，会直接添加到对应的位置中

        2.当计算出来的数组位置已经有值时,【JDK8开始时】把新添加的元素直接挂在老元素下面形成新的链表。就是下面这种情况：

额外还有一个条件:为了提高性能，当链表长度超过8或者数组长度大于等于64时，链表自动转成红黑树:

小结:

        1.HashMap底层时哈希表结构的

        2.依赖hashCode方法和equals方法保证键的唯一性

        3.如果键存储的时自定义对象,需要重写hashCode和equals方法；如果值存储自定义对象,不需要重写hashCode和equals方法

源码解析搞懂HashMap

加载因子:加载因子是HashMap中的一个重要参数，它表示哈希表在何时进行扩容操作。

1.先看我们创建一个HashMap会进行什么操作

HashMap<String,String>hm=new HashMap<>();

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //1.创建hashMap时初始化数组的大小为16
    static final int MAXIMUM_CAPACITY = 1 << 30; //数组的最大容量
    static final float DEFAULT_LOAD_FACTOR = 0.75f;//默认的加载因子为0.75
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
    }
//默认空参构造方法默认初始化加载因子为0.75
//此时底层数组还没有创建

当使用put方法的时候会创建数组

 hm.put("英雄","马超");

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);//调用了putVal方法
        //第一个参数计算哈希值
        //第二个参数是键
        //第三个参数是值
        //第四个参数是表明键值相同时,当前数据是否保留,false表示重复数据不保留，会覆盖
}

 先看putVal第一个参数hash(Key)

//可以看到这里时计算键的哈希值,当键为null的时候返回0，键值不为null的时候，计算键的哈希值
//这里也证明一点 哈希值计算只跟键有关,和值没有任何关系
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

第一种情况.数组位置为Null,首次添加

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; //定义一个局部变量用来计算哈希表数组的地址值
        Node<K,V> p; //临时的第三方变量，用来记录键值对对象的地址值
        int n; //记录当前数组的长度
        int i;//记录索引
        
        tab=table;//把哈希表中的数组值,赋值给局部变量tab
        if (tab== null || (n = tab.length) == 0)
            //如果当前是第一次添加数据,则会创建一个默认长度为16,加载因子为0.75的数组
            //如果不是第一次添加数据,会看数组中的元素是否达到了扩容的条件
            tab = resize();
            n =tab.length;
        i = (n - 1) & hash;//数组的长度跟键的哈希值进行计算，计算出当前键值对对象,在数组中应该存入的位置
        p = tab[i];//获取到数组中的元素
        if (p == null)//第一次添加数据的话,首次就是null,创建一个新的键值对对象，并且其存入tab[i]
            tab[i] = newNode(hash, key, value, null);
        else {//首次创建不会走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;//并发修改异常有关，暂时不需要了解
        //threshold=数组的长度*0.75 哈希表的扩容实际, ++size 先添加在判断
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;//首次添加的话,就表明当前添加没有覆盖任何元素，直接返回
    }

 resize()函数解析

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//首次添加的话是null,赋值给OldTab
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //oldCap代表旧的容capacity 首次设置为0 首次初始化因为oldCap为0所以直接跳转到else
        int oldThr = threshold;//旧的扩充时机
        int newCap;//初始化新的容量 
        int newThr = 0;
        if (oldCap > 0) {//非首次添加 从上面的putVal的代码中
            //if (++size > threshold) resize(); //当达到扩容条件 扩容条件为12 
            if (oldCap >= MAXIMUM_CAPACITY) {//这里大于最大容量，我们先看正常添加不超过的情况
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //newCap = oldCap << 1 新的容量扩充为老容量的2倍,在判断是否满足小于MAXIMUM_CAPACITY最大容量,然后老容量同时也大于最大的阈值
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY) 
                newThr = oldThr << 1; //把阈值设置为原来的两倍就是24 假设原来12
        }
        else if (oldThr > 0) 
            newCap = oldThr;
        else {//首次初始化               
            newCap = DEFAULT_INITIAL_CAPACITY;//首次加载默认初始化的容量为16
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//默认的扩充时机为加载因子*16=12
        }
        if (newThr == 0) {//阈值为0，刚开始创建时，为新阈值赋值=加载因子0.75*新容量16
            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]; //首次会创建一个长度为16的数组
        table = newTab;//新创建的数组赋值给成员变量tab 
        //第一次添加的话就不会走下面 
        //当将旧的数组内容存到新的数组中去
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    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
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            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;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;//把新的数组返回
    }

第二种情况：数组位置不为Null,键不重复，挂在下面形成链表或者红黑树

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; //定义一个局部变量用来计算哈希表数组的地址值
        Node<K,V> p; //临时的第三方变量，用来记录键值对对象的地址值
        int n; //记录当前数组的长度
        int i;//记录索引
        
        tab=table;//把哈希表中的数组值,赋值给局部变量tab
        if (tab== null || (n = tab.length) == 0) //这里的tab不是null，所以把n=tab.length
            //如果当前是第一次添加数据,则会创建一个默认长度为16,加载因子为0.75的数组
            //如果不是第一次添加数据,会看数组中的元素是否达到了扩容的条件
       
            tab = resize();
            n =tab.length;
        i = (n - 1) & hash;//数组的长度跟键的哈希值进行计算，计算出当前键值对对象,在数组中应该存入的位置
        p = tab[i];//获取到数组中的元素
        if (p == null) //当前不是Null，所以会走else的代码
            tab[i] = newNode(hash, key, value, null);
        else {//数组位置不为null
            Node<K,V> e; 
            K k;//存放键
            //p.hash==hash 这里是键不重复,所以当前if不会走 
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode) //判断当前节点是不是红黑树的节点,如果是的话,就会按照红黑树的规则添加 [当链表长度超过8或者数组长度大于等于64时，链表自动转成红黑树:]
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {//按照链表的规则添加
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {//查看当前节点的下面的节点是不是null。若是则走下面
                        //创建一个新的节点挂在下面形成链表
                        p.next = newNode(hash, key, value, null);
                        //判断长度是否超过8，然后进一步判断下面的函数是否转为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;//如果为Null的话,直接跳出
                    }//下面因为键不相同所以不会走
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;//相当于p=p.next 因为上面的e=p.next,也就是或找到一个链表下面不挂节点的节点,把新节点放再其下面
                }
            }
            if (e != null) { //这里e不是Null
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;//并发修改异常有关，暂时不需要了解
        //threshold=数组的长度*0.75 哈希表的扩容实际, ++size 先添加在判断
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;//首次添加的话,就表明当前添加没有覆盖任何元素，直接返回
    }

第三种情况：数组位置不为Null,键重复，元素覆盖

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; //定义一个局部变量用来计算哈希表数组的地址值
        Node<K,V> p; //临时的第三方变量，用来记录键值对对象的地址值
        int n; //记录当前数组的长度
        int i;//记录索引
        
        tab=table;//把哈希表中的数组值,赋值给局部变量tab
        if (tab== null || (n = tab.length) == 0) //这里的tab不是null，所以把n=tab.length
            //如果当前是第一次添加数据,则会创建一个默认长度为16,加载因子为0.75的数组
            //如果不是第一次添加数据,会看数组中的元素是否达到了扩容的条件
       
            tab = resize();
            n =tab.length;
        i = (n - 1) & hash;//数组的长度跟键的哈希值进行计算，计算出当前键值对对象,在数组中应该存入的位置
        p = tab[i];//获取到数组中的元素
        if (p == null) //当前不是Null，所以会走else的代码
            tab[i] = newNode(hash, key, value, null);
        else {//数组位置不为null
            Node<K,V> e; 
            K k;//存放键
            //p.hash==hash 
                这里是键是重复的，值是不一样的
            这里有两种情况
            1.要添加的是(aaa,555) 添加位置的数组第一个位置元素为(aaa,666),这里的话直接走if语句,然后把p赋值给e；
            2.情况2就是链表中有好多元素，但是其中链表中的其中一个元素(非第一个)和要添加的元素的哈希值一样并且键也一样，也要尽心覆盖操作，走下面的else if/else操作
            //p.hash代表的是数组中键值堆的哈希值,hash代表要添加的键值对的哈希值
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode) //判断当前节点是不是红黑树的节点,如果是的话,就会按照红黑树的规则添加 [当链表长度超过8或者数组长度大于等于64时，链表自动转成红黑树:]
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {//按照链表的规则添加
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {//查看当前节点的下面的节点是不是null。若是则走下面
                        //创建一个新的节点挂在下面形成链表
                        p.next = newNode(hash, key, value, null);
                        //判断长度是否超过8，然后进一步判断下面的函数就是转为红黑树
                        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;//所以把e赋值给p
                }
            }
            if (e != null) { //这里e不是Null
                V oldValue = e.value; //把当前的值复制给oldValue
                if (!onlyIfAbsent || oldValue == null)//要进行覆盖操作
                    e.value = value;//直接把当前值替换为value
                afterNodeAccess(e);
                return oldValue;//返回覆盖前的值
            }
        }
        ++modCount;//并发修改异常有关，暂时不需要了解
        //threshold=数组的长度*0.75 哈希表的扩容实际, ++size 先添加在判断
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;//首次添加的话,就表明当前添加没有覆盖任何元素，直接返回
    }

内容部分来自集合进阶-06-HashMap基本的使用_哔哩哔哩_bilibili

qq_44766305
关注
  • 17
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java基础-HashMap
qq_43989788的博客
02-18 1万+
HashMap主要用于存储键值对，是最常用的java集合之一。 Map<String,Object> map = new HashMap<>(); HashMap在JDK1.7和JDK1.8的实现是不一样的。 JDK1.7中的HashMap实现： 数据结构：数组+链表 Map<String,String> map = new HashMap<>(5); map.put("name","heidan"); map.put("age","21");
java-HashMap-loop
03-22
这个"java-HashMap-loop"可能是指在遍历`HashMap`时遇到的一个问题，即由于某种原因导致的无限循环。 首先，我们需要了解`HashMap`的基本操作。`HashMap`中插入元素使用`put()`方法，查询元素使用`get()`方法，删除...
java--HashMap
qq_47044642的博客
02-12 1282
HashMap 1、HashMap位于util包，使用前要引用，import java.util.HashMap，HashMap是一个无序的散列表，存储的内容是键值对映射(key-value)，具有很快的访问速度，最多允许一条记录的键为 空。HashMap 的 键 （key）与 值（value） 类型可以相同也可以不同，可以键和值都是整型，也可以键是字符串，值是整型，反过来也可以。 2、创建方式：HashMap<Integer, String> Sites = new HashMap<In
Java－HashMap数据结构
了解➔熟悉➔掌握➔精通
12-26 748
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net HashMap采用的就是哈希表，那他是怎么存储的呢？比如HashMap要put一个Key和Value？ 首先，对Key值进行hash计算，计算一个hash值。然后对计算出的hash值和数组长度取模，这样取模后的数据一定小于数组的长度。 比如数组长度为16，那么计算出来的值是在0-15之间，然后就把0-15对号入座。相应下标的数组上，如果此时数组这个位置已经
java--HashMap的方法汇总
weixin_44431073的博客
12-28 1207
Java、 HashMap 、方法汇总
【JAVA-Day53】Java集合类HashMap详解
热门推荐
沉淀、分享、成长，让自己和他人都能有所收获！
10-26 2万+
作为一名Java开发者，熟练掌握集合类是至关重要的。其中，HashMap作为Java中常用的集合类之一，具有重要的地位。本篇博客将带您深入了解HashMap的各种操作技巧、实际应用场景以及面试可能涉及的问题，同时深度探讨其实现原理与性能优化，让您全面掌握HashMap的精髓。HashMap是Java中的一种数据结构，它提供了一种键值对的映射关系，允许使用键来查找值。在实际开发中，它能够高效地进行数据存储和检索，是Java编程中常用的集合类之一。
Java-HashMap.rar_hashmap_java hashmap
09-24
在Java编程语言中，`HashMap`是`java.util`包中的一个核心类，它属于集合框架的一部分，主要用于存储键值对的数据结构。`HashMap`基于哈希表（散列表）实现，提供了快速的插入、删除和查找操作，平均时间复杂度为O(1...
JAVA--HashMap热门面试题
08-19
JAVA--HashMap热门面试题 HashMap 是 Java 中一个常用的集合框架，特别是在面试中，它是最常被问到的问题之一。在这里，我们将讨论一些热门的 HashMap 面试题，以帮助您更好地理解 HashMap 的工作原理和应用。 为...
java-hashmap:Java HashMap的插图
05-19
Java HashMap的插图 Java HashMap HashMap类使用哈希表来实现Map接口。 这样，即使对于大型集合，诸如get（）和put（）之类的基本操作的执行时间也可以保持恒定。 目录 插图1：使用put（）方法在HashMap中创建和...
java7hashmap源码-JAVA-:JAVA-
06-04
java7 hashmap源码 Notes 原理 basic 1 数据结构中各种东西的数量很很重要！！！可以考虑在在数据结构中定义一下 2 Java hashtable的contains用来查找是否存在value，和containsValue类似 查找key使用containskey...
spring事务详细讲解-深入浅出
小电玩
09-08 483
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1470
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 542
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 562
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
自定义Stater
m0_63624484的博客
09-07 725
我们平时在导入依赖的时候，大部分导入的都是xxx-spring-boot-stater。那是因为它们都基于spring的规则将写好的框架定义成一个stater，这样方便springboot引用它们写好的功能。那我们为什么也要自定义stater呢？
Linux服务器Java启动脚本
Jack魏
09-08 557
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 333
步骤很详细，直接上教程……
Springboot废品回收系统---附源码86799
weixin_BYSJ1987的博客
09-07 1298
在系统的设计与实现中，本论文主要包括以下几个方面：首先，设计了系统的功能模块，包括用户注册登录、商品信息发布、回收订单管理等；其次，利用SpringBoot的特性，搭建了系统的后端框架，并实现了相应的业务逻辑；最后，使用前端技术，设计了用户友好的界面，使用户可以方便地使用系统。
基于Spring Boot开发一个二手交易平台系统
嵌入式行业打工人，不定期更新博客。
09-08 976
这个示例提供了一个非常基础的框架，你可以在此基础上扩展更多的功能，如商品搜索、购物车、支付接口等。在实际开发过程中，还需要考虑诸如错误处理、事务管理、日志记录等方面的问题。此外，确保所有的API调用都是安全的，并且正确处理用户的输入数据，防止SQL注入等安全风险。如有疑问可以评论或者私信，看到一定解答。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值