Java重点源码回顾——HashMap1.7

最新推荐文章于 2023-06-29 18:41:23 发布
最新推荐文章于 2023-06-29 18:41:23 发布
阅读量849 收藏 1
点赞数
分类专栏： Java容器源码 文章标签： java HashMap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41799019/article/details/128497770
版权

1. 概述

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable

HashMap在我们的日常使用中非常多，所以今天来阅读下它的源码，了解它具体的设计思想，能够帮助我们扩宽视野。

HashMap两个主要的版本是1.7和1.8，都是线程不安全的。1.8版本是在1.7版本的基础上引入了红黑树等优化，提升整体的效率。今天我们先来简单了解下HashMap1.7版本的源码。它的主要特点总结如下：
在这里插入图片描述

在HashMap1.7中，并没有引入红黑树。所以采用的方式还是拉链法。
在这里插入图片描述

2. 成员变量

因为HashMap1.7是采用拉链法存储数据的，所以需要将key-value键值对封装成一个节点类，如下所示：

    static class Entry<K,V> implements Map.Entry<K,V> {
        final K key;  // 存储key
        V value;  // 存储value
        Entry<K,V> next;  // next指针，又来指向下一个节点
        final int hash;  // hash值
    }

从代码上可以看到，实现方法是使用静态内部类Entry来充当节点类的。next指针是当出现哈希冲突的时候，用来指向下一个节点的指针。

我们再看看其它的成员变量：

    // 默认初始化容量
    static final int DEFAULT_INITIAL_CAPACITY = 16;

    // HashMap能够存储的最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;

    // 默认负载因子，用来指示元素个数占整体容量的比例
    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    // 用来存储键值对的Entry数组
    transient Entry[] table;

    // 存储实际元素个数
    transient int size;

    // 阈值=容量 * 负载因子。当超过这个数字，说明可能哈希冲突严重，需要扩容
    int threshold;

    // 实际的负载因子
    final float loadFactor;

    // 更新操作计数器，线程不安全时进行fail-fast机制
    transient int modCount;

成员变量需要注意的地方主要有两点：

  1. HashMap的容量在任何时刻都是2的n次幂，包括在扩容的时候也是扩容为原来的2倍。这主要是因为当容量为2的n次幂的时候，可以减少哈希碰撞的概率。具体可见HashMap初始容量为什么是2的n次幂及扩容为什么是2倍的形式。
  2. 阈值threshold=容量 * 负载因子，当超过阈值，可能有比较严重的哈希冲突，需要进行扩容。

3. 构造方法

    // 两个参数的构造方法
    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);

        // 传入的容量并不一定是2的n次幂，所以要找到最小的二次幂容量
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;
        // 实际负载因子
        this.loadFactor = loadFactor;
        // 阈值
        threshold = (int)(capacity * loadFactor);
        // 根据容量创建数组
        table = new Entry[capacity];
        init();
    }

    // 一个参数的构造方法，使用默认负载因子0.75
    public HashMap(int initialCapacity) {
        this(initialCapacity, DEFAULT_LOAD_FACTOR);
    }

    // 无参构造方法，使用默认容量16，默认负载因子0.75
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR;
        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);
        table = new Entry[DEFAULT_INITIAL_CAPACITY];
        init();
    }

    // Nap迁移
    public HashMap(Map<? extends K, ? extends V> m) {
        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
                      DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
        putAllForCreate(m);
    }

可以看到，有4个构造方法，会使用2的n次幂来计算初始容量，并通过负载因子计算阈值。

4. put方法

    public V put(K key, V value) {
        // 如果key为null，单独处理
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());  // 计算hash值
        int i = indexFor(hash, table.length);  // 计算位置
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            // 相同的key进行覆盖
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;  // 更新次数+1
        addEntry(hash, key, value, i);  // 没有找到相同的
        return null;
    }

    // 如果key为null
    private V putForNullKey(V value) {
        // key为null的键值对，默认存放在0号位置
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            // 找到相同的key进行覆盖
            if (e.key == null) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
        modCount++;
        addEntry(0, null, value, 0); // 没有找到相同的
        return null;
    }

    // 扰动函数
    static int hash(int h) {
        // 通过位运算进行扰动，减少哈希冲突
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    // 计算Entry在数组中的位置
    static int indexFor(int h, int length) {
        // 和长度-1进行与运算，相当于进行模n计算。
        return h & (length-1);
    }

    // 添加Entry
    void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];  // 获取数组中bucketIndex的位置
        // 头插法插入元素
        table[bucketIndex] = new Entry<>(hash, key, value, e);
        // 插入阈值就进行扩容，为2倍原来的大小
        if (size++ >= threshold)
            resize(2 * table.length);
    }

在上面的代码中，我们可以看到HashMap1.7中，是对于key为null的情况单独处理，放在
数组中0的位置上。我们对put方法的流程进行下总结：

  1. 如果key为null，则单独处理。否则进入下一步；
  2. 通过扰动函数计算哈希值，并计算出要插入的位置i；
  3. 如果在i位置上找到了相同的key，则将value进行覆盖；如果没有找到相同的key，则创建新的Entry，利用头插法进行插入；
  4. 如果发现Entry个数超过阈值，则进入扩容，扩大容量为原来的2倍。

5. resize方法

    // 扩容的方法
    void resize(int newCapacity) {
        Entry[] oldTable = table;  // 旧的数组
        int oldCapacity = oldTable.length;  // 旧的容量
        if (oldCapacity == MAXIMUM_CAPACITY) { // 如果本身达到了最大的容量
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];  // 创建新的数组
        transfer(newTable);  // 迁移旧的Entry到扩容后的数组中
        table = newTable;   // 将table指向新的数组
        threshold = (int)(newCapacity * loadFactor);  // 重新计算阈值
    }

    // Entry进行迁移
    void transfer(Entry[] newTable) {
        Entry[] src = table;   // 旧数组
        int newCapacity = newTable.length;   // 新的容量
        for (int j = 0; j < src.length; j++) {  // 遍历旧数组中的每个桶
            Entry<K,V> e = src[j];  // 桶中的第一个元素
            if (e != null) {   // 如果不为null
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;  // 先保存下一个要transfer的Entry
                    int i = indexFor(e.hash, newCapacity); // 计算新数组中的位置
                    e.next = newTable[i];  // 头插法插入元素
                    newTable[i] = e;  // 更新新数组中i位置第一个元素为e
                    e = next;  // e更新为旧数组中i位置下一个元素为e
                } while (e != null);
            }
        }
    }

在HashMap1.7扩容方法中，是将容量扩大为原来的2倍。扩容的过程如下：

  1. 创建2倍容量的新数组；
  2. 遍历旧数组中的每个桶，再遍历每个桶中的Entry，重新计算Entry在新数组中的位置，然后利用头插法的方式插入元素。

6. get方法

    // get元素
    public V get(Object key) {
        // key为null单独处理
        if (key == null)
            return getForNullKey();
        // 根据key计算hash值
        int hash = hash(key.hashCode());
        // 遍历桶中的Entry
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            // 如果发现相同的key，就返回value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

    // 如果key为null，就去数组中0位置去查找
    private V getForNullKey() {
        for (Entry<K,V> e = table[0]; e != null; e = e.next) {
            if (e.key == null)
                return e.value;
        }
        return null;
    }

get方法就比较简单，先根据hash值计算出在数组中的位置，如果发现相同的key的Entry，就返回值。

7. remove方法

    // remove方法
    public V remove(Object key) {
        Entry<K,V> e = removeEntryForKey(key);
        return (e == null ? null : e.value);
    }

    // 根据key删除Entry
    final Entry<K,V> removeEntryForKey(Object key) {
        // 计算hash值
        int hash = (key == null) ? 0 : hash(key.hashCode());
        // 计算数组中的位置
        int i = indexFor(hash, table.length);
        Entry<K,V> prev = table[i];  // 前驱节点
        Entry<K,V> e = prev;  // 当前节点

        // 遍历桶中所有的Entry
        while (e != null) {
            Entry<K,V> next = e.next;
            Object k;
            // 如果发现key相同的Entry
            if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
                modCount++;
                size--;  // 元素个数-1
                if (prev == e)  // 如果删除的是头节点
                    table[i] = next;  // 那么下个节点就作为新的头节点
                else  // 删除的是中间节点
                    prev.next = next;  // 前驱节点指向下一个节点
                e.recordRemoval(this);
                return e;
            }
            prev = e;
            e = next;
        }

        return e;
    }

remove方法也比较简单，通过hash值计算出在数组中桶的位置，然后遍历桶中的Entry，找到相同的key就删除。

8. 扩容出现死循环

HashMap1.7是使用头插法插入节点的，在进行扩容调用resize方法，进而调用transfer方法迁移元素的时候，如果多线程并发，就有可能出现链表死循环的问题。具体描述可见Java：手把手带你源码分析 HashMap 1.7

参考文章：
Java：手把手带你源码分析 HashMap 1.7
为什么HashMap会产生死循环
HashMap1.7 最最最最最详细源码分析

George&Rita
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HashMap1.7源码详解
wk_java_1619的博客
12-19 496
本文主要分析HashMap类的源码。
【源码解析】HashMap扩容机制
最新发布
2401_83916394的博客
04-18 427
对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。再分享一波我的Java面试真题+视频学习详解+技能进阶书籍《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />对于很多Java工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。
HashMap的扩容机制
qq_39350797的博客
06-29 842
HashMap的扩容机制在jdk1.7和jdk1.8有什么不同
解析JDK1.7 HashMap 头插法生成的环形链表死循环问题
是狮不是猿
03-25 5358
背景 在JDK1.7中HashMap使用头插法来添加同一位置上的节点,但是在并发的情况下使用HashMap，在进行resize()扩容的过程中，链表可能会形成环状，当在读取HashMap元素的时候会出现死循环，CPU占用标高，服务器崩溃的问题。 扩容前 正常 resize() 后 并发 resize() 形成环状 在下面我会说明是如何生成该环状 正常扩容resize()的过程 以下执行的过程是在同一链表元素的key值rehash后落到同一坐标上为基础 我们需要关注的是HashMap的resize()方
多图详解的HashMap1.7扩容死循环
马疯蜗的博客
07-24 2946
HashMap扩容过程详解一、1.7HashMap扩容死循环1.产生原因二、1.8HashMap扩容流程 一、1.7HashMap扩容死循环 1.产生原因 1.7HashMap在高并发场景下，会发生扩容链表死循环问题！ 二、1.8HashMap扩容流程
这里有你想看的最全的HashMap扩容过程！---基于HashMap源码，非常详细的总结HashMap构造过程、插入过程、位运算细节、扩容机制，红黑树转化。
RSDYS的博客
07-28 2375
面试必刷，基于HashMap源码，总结HashMap扩容机制，红黑树转化，个人总结。
javahashmap源码-java_HashMap_jdk1.7:我的hashmap
05-24
java hashmap 源码
Java——HashMap
12-21
Java——HashMap HashMap 底层: 哈希表存储(数组+链表+红黑树) 特点: 查询,增删效率高,但是无序,存储键值对的值 去重: 根据key做去重,根据key计算桶的位置 扩容: 初始容量: 默认初始用量为16 加载因子: 0.75 当16*...
Java源码解析HashMap简介
08-26
Java源码解析HashMap简介 HashMap是Java开发中最常用的集合之一，它基于hash表的实现，提供了map的所有可选操作，并且允许null值和一个null的key。HashMap的实现提供了常量级的性能，假设hash函数把元素们比较好的...
java7hashmap源码-java:Java
06-04
hashmap源码 Table Of Contents day01_JAVA语言概述与基本语法：标识符、变量也变量分类、源码_反码_补码、进制转换、编码与字符集 day02_基本语法.运算符：算术运算符、赋值运算符、比较运算符、逻辑运算符、位...
Java源码角度分析HashMap用法
08-28
Java源码角度分析HashMap用法 Java源码角度分析HashMap用法主要介绍了Java源码角度分析HashMap用法，具有一定借鉴价值，需要的朋友可以参考下。下面我们将从HashMap的优点、缺点、使用方法、源码分析等方面进行深入...
HashMap源码(JDK1.7,含注释)
06-02
HashMap源码(JDK1.7,含注释)
1.7 HashMap源码分析
攻城老湿的博客
02-13 613
1.存储结构 HashMap的内部存储结构其实是数组和链表的结合。当实例化一个HashMap时，系统会创建一个长度为Capacity的Entry数组，这个长度被称为容量(Capacity)，在这个数组中可以存放元素的位置我们称之为“桶”(bucket)，每个bucket都有自己的索引，系统可以根据索引快速的查找bucket中的元素。 每个bucket中存储一个元素，即一个Entry对象，但每一个E...
HashMap1.7 扩容产生环形链表
weixin_42496727的博客
04-12 1506
场景 两个线程同时put，发现HashMap需要扩容。 执行代码现场 HashMap真正的resize是在transfer方法里面完成的。 void transfer(Entry[] newTable, boolean rehash) { int newCapacity = newTable.length; for (Entry<K,V> e : table) { while(null != e) { Ent
HashMap实现原理及源码分析JDK1.7
泯灭于众生，高歌于孤夜！
07-12 196
HashMap实现原理及源码分析
Java基础面试题(下)
小猪呀的博客
09-16 1068
1.Collection下的常用子类集合有那一些？ 有List，Set。 List：有序(按添加顺序显示)，可重复，set：无序(按大小排序显示)，不可重复，map：以键值对方式存储 List分别有： ArrayList：是List的主要实现类，ArrayList的底层是数组。线程不安全的。查找快，增删慢(通过首地址+下标获取元素位置，增删要移动某一些元素)” LinkedList：底层是一个双向链表(是一个带头/尾指针的双向链表，)。插入，删除快（增删快因为直接就在对应的位置设置新的元素指向前后
JDK1.7的HashMap源码分析
xiaobo5264063的博客
03-01 382
HashMap介绍 jdk1.7的HashMap是基于数组+链表 jdk1.7的HashMap是基于数组+链表+红黑树 a a a a a a a a a a a a a a a ...
Hashmap的结构，1.7和1.8有哪些区别
weixin_49193222的博客
12-04 1274
不同点： （1）JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法，那么他们为什么要这样做呢？因为JDK1.7是用单链表进行的纵向延伸，当采用头插法时会容易出现逆序且环形链表死循环问题。但是在JDK1.8之后是因为加入了红黑树使用尾插法，能够避免出现逆序且链表死循环的问题。 （2）扩容后数据存储位置的计算方式也不一样：1. 在JDK1.7的时候是直接用hash值和需要扩容的二进制数进行&（这里就是为什么扩容的时候为啥一定必须是2的多少次幂的原因所在，因为如果只有2的n次幂的情况...
HashMap 1.7源码解析
Always`的博客
10-23 1245
HashMap 1.7源码解析 1.介绍 1.描述 ​ HashMap在我们平常开发中使用非常广泛,本文就从JDK1.7 分析HashMap相关源码（后续再加上1.8）. 在JDK1.7中HashMap底层是由数组+链表实现的,每次在插入数据的时候,会根据key来计算对应的Hash.使用各种位操作将Hash值转换成对应的数组下标,根据下标来找到数组(Entry)对应位置.如果当前位置对应的Entry对象不为空,则以头插的方式将数据插入到链表中.如果为空的话,直接将数据插入到Entry数组中.
Java——hashMap去重和排序
06-06
要对 Java 的 HashMap 进行去重和排序，可以先将其转化为一个 List，并使用 Java 8 的 Stream API 进行操作。 去重： ```java HashMap, String> hashMap = new HashMap(); // 假设 hashMap 已经填充了键值对 List,...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值