JAVA集合学习之HashMap

最新推荐文章于 2023-04-15 23:31:09 发布
最新推荐文章于 2023-04-15 23:31:09 发布
阅读量198 收藏 1
点赞数
分类专栏： 集合学习 文章标签： java hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36674140/article/details/105622675
版权

JAVA集合学习之HashMap

HashMap集合的继承和实现关系

hashmap

HashMap类中的属性

属性作用重点
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4默认初始容量（容量指的是散列表数组的容量）十进制： 16
static final int MAXIMUM_CAPACITY = 1 << 30最大容量（同上）十进制： 1 073 741 824
static final float DEFAULT_LOAD_FACTOR = 0.75f默认的负载因子用于计算扩容的阀值
static final int TREEIFY_THRESHOLD = 8散列表的链表转换为红黑树的阀值当一个链表的长度大于等于8时，就会把该链表转化为一个红黑树，以提高查询效率。
static final int UNTREEIFY_THRESHOLD = 6节点数小于等于6时，把树转化为链表只有在扩容时才会进行转换。
static final int MIN_TREEIFY_CAPACITY = 64链表转换为红黑树的最小阀值如果散列表的数组长度小于64，即使链表长度大于等于8也不会转化为红黑树，但是会对数组进行扩容为原来的两倍。
transient Node<K,V>[] table存储散列表的数组这个数组的长度一定是2的幂。（MUST be a power of two）
transient Set<Map.Entry<K,V>> entrySet保存缓存
transient int size记录添加的元素的数量根据该值进行判断是否进行扩容
transient int modCountfail-fast机制的判断变量
int threshold存储扩容的阀值，也是指定初始化数组长度的值size大于这个值就会进行扩容；当时使用指定容量的初始化函数时，数组长度会使用这个值进行初始化。
final float loadFactor存储自定义的阀值在初始化HashMap时进行赋值

HashMap的初始化函数

/* 无参构造函数*/
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // 设置默认的负载因子 0.75
    }

/* 有参构造函数*/
public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);//调用的下面的一个构造函数
    }

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);//返回一个比initialCapacity大的第一个2的幂的数
    }

public HashMap(Map<? extends K, ? extends V> m) {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        putMapEntries(m, false);
    }

添加第一个元素

1.初始化HashMap
public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // 加载默认初始化的负载因子 0.75
    }
2.调用put(K key, V value)
/**
 * 调用put函数添加元素，
 * put元素调用了putVal函数，并且传入了key的hash值和添加的元素。
 *
 */
public V put(K key, V value) {
       return putVal(hash(key), key, value, false, true);
   }

/**
 * 调用putVal函数，进行元素的插入
 * 或者在这判断是否需要扩容
 */
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)//当table为空进入
            n = (tab = resize()).length;//tab = resize()实现tab的初始化 并返回一个Node数组（在扩容时已经把赋值给了table）
  ------------------------------------------------hash不冲突--------------------------------------------------------
        if ((p = tab[i = (n - 1) & hash]) == null)//判断该位置是否已经有元素
            tab[i] = newNode(hash, key, value, null);
  ------------------------------------------------hash冲突--------------------------------------------------------
        else {//当hash冲突后进入
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))//判断添加key是不是同一个
                e = p;//如果key相同就进行覆盖
            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 //链表的节点数大约等于8个后，哈链表转换为红黑树
                            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 e不为空说明有相同的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;
    }

​ 当调用put方法时其实调用的是putVal方法，而putVal方法的 onlyIfAbsent 表示是否可以覆盖相同key的value，默认是关闭的，表示可以进行覆盖。在该方法中：

  • tab = resize() 当添加第一个元素时执行，就行数组的初始化。（629行）
  • treeifyBin(tab, hash) 当链表的长度大于等于8把链表转换为红黑树,该方法中不一定会树化，也可能的扩容。（644行）
3.resize()扩容
final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;//扩容阀值
        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)//久数组要大于等于默认的16
                newThr = oldThr << 1; // double threshold 扩容阀值在扩大一倍
        }
        else if (oldThr > 0) // initial capacity was placed in threshold 如果初始化了容量大小进入
            newCap = oldThr;    //使用初始化容量时会给threshold赋值
        else {               // zero initial threshold signifies using defaults 使用无参构造函数 ：数组长度为0 第一个元素添加进入时的初始化
            newCap = DEFAULT_INITIAL_CAPACITY;//初始化容量大小
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//计算阀值
        }
        if (newThr == 0) {//使用有产初始化后threshold实际存储的是数组的长度
            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) {//当oldTab等于空时，说明是第一次扩容，不需要把原来的数组进行转移到新的数组
            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;//通过hash值重新计算索引值，并且把值赋值给新的数组
                    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;                // xxx0 xxxx    // xxx1 xxxx
                            if ((e.hash & oldCap) == 0) { // 0001 0000 ==>// 0010 0000
                                if (loTail == null)       // 0000 0000    // 0000 0000
                                    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;
    }

扩容时分为三种不同的情况：

  1. 已经初始化完成，散列表已经存在，oldCap>0 为true该if语句块内进行了数组长度的增加 oldCap << 1 使用的位运算，相当于原数组长度乘2，在对下次的扩容阀值进行计算。
  2. 使用了指定容量的构造函数，进行初始化。但是HashMap中并没有一个存储数组长度的变量，所有在把指定的容量暂时存储在了threshold这个变量中，进入该扩容函数后会先把这个值赋值给oldThr，当第一次添加元素时因为 oldThr > 0 为true进行进入if语句块中，把这个临时存储在oldThr中的值赋值给了newCap，这样就实现了对于数组长度的控制。
  3. 使用无参构造函数进行初始化，没有指定任何变量大小完全默认初始化，设置数组长度为16和负载因子为0.75。

什么时候把链表转换为红黑树？

在putVal函数第644行调用了treeifyBin函数并且传入了临时的散列表tab和要进行树化的链表的hash值。

final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)//数组的长度小于64也不会进行树化而是选择扩容
            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);
        }
    }

树的转换看不懂。

HashMap还是有点东西！

泡椒酸菜
关注
专栏目录
Java 集合框架：HashMap 的介绍、使用、原理与源码解析
栗筝i的博客
07-23 7000
HashMap 根据是一个键值对集合，采用 hashCode 值存储数据，大多数情况下可以直接定位到它的值，因而具有很快的访问速度，但遍历顺序却是不确定的。HashMap 最多只允许一条记录的键为 null。HashMap 非线程安全，即任一时刻可以有多个线程同时写 HashMap，可能会导致数据的不一致。如果需要满足线程安全，可以用 Collections 的 synchronizedMap 方法使 HashMap 具有线程安全的能力，或者使用 ConcurrentHashMap。
java二维集合_java集合学习笔记--二维集合HashMap
weixin_28717467的博客
02-12 1164
一.Map集合在二维集合中，使用最多的是java.util.HashMapHashMap类提供了二维集合的功能构造函数public HashMap()HashMap类中，可以为每个对象指定一个key值。如果为两个不同的对象指定同一个key值，后面的将会把前面的覆盖。对象在HashMap中没有顺序。HashMap中一些主要的方法：1.清空HashMappublic void clear()2.判断是...
Java集合类之Map的HashMap之常用方法的使用
qq_45823118的博客
11-30 7060
Java集合类之Map的HashMap之常用方法的使用 任务描述 使用 HashMap 集合操作菜单 相关知识 1.什么是 HashMap HashMap 是 Map 接口的实现类，它存储的内容是键值对(key-value)映射，其中 key、value 都可以为 null。 HashMap 是无序的，即被存入到 HashMap 中的元素，在遍历 HashMap 时，其输出是无序的。 2.创建 HashMap 集合 使用以下代码即可创建一个 HashMap 集合。 public static v
学习-Java集合类之Map的HashMap之常用方法的使用
qq_45870659的博客
11-05 4549
任务描述 本关任务：使用 HashMap 集合操作菜单。 相关知识 什么是 HashMap HashMap 是 Map 接口的实现类，它存储的内容是键值对(key-value)映射，其中 key、value 都可以为 null。HashMap 是无序的，即被存入到 HashMap 中的元素，在遍历 HashMap 时，其输出是无序的。 创建 HashMap 集合 使用以下代码即可创建一个 HashMap 集合。 public static void main(String[] args
第1关：学习-Java集合类之Map的HashMap之常用方法的使用
最新发布
m0_73614626的博客
04-15 818
HashMap 是 Map 接口的实现类，它存储的内容是键值对(key-value)映射，其中 key、value 都可以为 null。HashMap 是无序的，即被存入到 HashMap 中的元素，在遍历 HashMap 时，其输出是无序的。
Java集合Map之HashMap常用操作
刘跃辉的博客
12-06 8120
Map是一个将键(key)映射到值(value)的对象 , Map中每一个元素都有一个key对象和value对象 , 并且key是不能重复的 , Map中有两个重要的实现类 , 一个是HashMap , 这个集合是无序且不安全的集合 , 最多有一个元素为null , 还有一个就是TreeMap , 可以对key进行排序 , HashMap底层是通过哈希表来实现的 , 所以可以先看一下我之前的一篇文章 :java集合框架Map之HashMap底层原理解析版本JDK1.7 : 数组 + 链表JDK1.8 :
Java集合系列之HashMap源码分析
08-27
Java集合系列之HashMap源码分析是Java集合系列中的一篇非常重要的文章，它详细介绍了Java集合系列之HashMap源码，具有很高的参考价值。下面我们将对HashMap源码进行详细的分析。 HashMap是基于哈希表实现的，它的...
Java集合之HashMap用法详解
08-30
Java集合之HashMap用法详解 Java集合之HashMap用法详解主要介绍了Java集合之HashMap用法，结合实例形式分析了java map集合中HashMap定义、遍历等相关操作技巧。 HashMap概述 HashMap是Java集合框架中最常用的Map...
深入Java集合学习系列：HashMap的实现原理
03-18
在Java编程语言中，集合框架是开发者日常工作中不可或缺的一部分，HashMap作为其中的重要成员，它的实现原理对于理解Java性能优化和数据结构有深远的意义。HashMap是一个基于哈希表的数据结构，它实现了Map接口，...
Java集合类之HashMap
一个苟且偷生程序员的博客
06-08 362
HashMap源码解析 老样子话不多说先上一张UML类图 看一下里面的方法，我们抽重点的和常用的讲 HashMap的构造方法 HashMap()方法 //负载因子 final float loadFactor; //默认负载因子为0.75 static final float DEFAULT_LOAD_FACTOR = 0.75f; public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defau
java hashmap 常用方法_Java集合之HashMap常用方法解析
weixin_30110543的博客
02-13 298
1 /**2 * 存放一个键值对3 *@paramkey 键4 *@paramvalue 值5 */6 publicV put(K key, V value) {7 //计算key的hash值，存放一个键值对8 return putVal(hash(key), key, value, false, true);9 }1011 /**12 *...
java用hashmap_Java集合之HashMap的用法
weixin_35315019的博客
02-25 238
Java集合之HashMap的用法在学习中，出现了几次对HashMap的使用不熟练的情况，现将HashSet的用法总结如下。1. 基本用法HashMap map = new HashMap<>();map.put("1", "a");map.put("2", "b");map.put("3", "a");map.put("4", "c");//map.put("4", "d"); /...
java中HashMap集合的常用方法
weixin_30408675的博客
08-21 309
public Object clone() 返回hashMap集合的副本 其余的方法都是实现Map集合的 https://www.cnblogs.com/xiaostudy/p/9510763.html 转载于:https://www.cnblogs.com/xiaostudy/p/9510969.html...
java集合学习之Map（一）HashMap
妈的小可爱
02-11 355
首先，本人鄙视了...........下面开始自己的知识整理--------------------------------------------------------------------------------------------------------------------先确定下几个概念1.HashMap采用的是数组加链表的形式存储数据2.HashMap中有DEFAULT_IN...
java hashmap的用法_Java集合之HashMap用法详解
weixin_42303461的博客
02-12 338
本文实例讲述了Java集合之HashMap用法。分享给大家供大家参考，具体如下：HashMap是最常用的Map集合，它的键值对在存储时要根据键的哈希码来确定值放在哪里。HashMap 中作为键的对象必须重写Object的hashCode()方法和equals()方法import java.util.Map;import java.util.HashMap;public class lzwCode ...
Java集合之HashMap分析和使用
世银的博客
02-25 396
一、概览 HashMap是最常用的集合之一，基于哈希表实现，用于存储键值对，从key映射到value，实现了Map接口 HashMap的几个特点： 允许 null key与null value ，也就是键值对均可为空 key 不能重复 HashMap是无序集合，无法保证元素的特定顺序 HashMap不是线程安全的 HashMap的get与put方法使用了hashCode() 和 equals(...
Java集合类学习--HashMap（一）
CodersCoder的博客
10-10 176
概述 HashMap采用key/value存储结构，每个key对应唯一的value，查询和修改的速度都很快，能达到O(1)的平均时间复杂度。它是非线程安全的，且不保证元素存储的顺序。 HashMap 是 Java 开发中最常用的容器类之一，也是面试的常客。JDK1.7之前是数组 + 链表 。在 JDK 1.8 做了优化，当链表长度达到一定数量时会把链表转为红黑树。 因此，JDK 1.8 中的 HashMap 实现可以理解为「数组 + 链表 + 红黑树」。内部结构示意图： HashMap 的继承结构和类签名
map集合
cang_ling的博客
02-07 428
HashMap集合 特点 常用方法 （1）put(Kkey,V value) 将键（key）/值（value）映射存放到Map集合中 public class Test { public static void main(String[] args) { HashMap<String, Integer> map = new HashMap<String, Integer>(); map.put("Tom", 100);//..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值