java集合之HashMap源码分析

最新推荐文章于 2024-08-26 19:43:03 发布
最新推荐文章于 2024-08-26 19:43:03 发布
阅读量371 收藏
点赞数
分类专栏： java集合 java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/showchi/article/details/106197947
版权

文章目录

HashMap基本介绍

  • 底层数结构

    • jdk_1.8之前的底层数据结构是数组 + 链表

    在这里插入图片描述

    • jdk_1.8之后的底层数据结构是数组 + 链表 + 红黑树

在这里插入图片描述

本篇主要分析的是jdk_1.8

  • 继承体系
public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {}
  1. 继承AbstractMap实现部分基本操作,如size(), containsKey()等。
  2. 实现 Map顶级接口。
  3. 实现了Cloneable接口，重写了clone()函数。
  4. 实现Serializable接口，支持序列化。
  • 重要属性
	// 默认初始容量
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

	// 最大容量
    static final int MAXIMUM_CAPACITY = 1 << 30;

	// 负载因子
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
    // 链表转红黑树的阈值 当链表长度大于此值时转成红黑树
    static final int TREEIFY_THRESHOLD = 8;
    
    // 红黑树转回链表的阈值 当红黑树节点数小于此值时转回链表
    static final int UNTREEIFY_THRESHOLD = 6;

	//  理解为hash表允许链表转树结构的最小值, 即 size > 此值  才允许链表转树
    static final int MIN_TREEIFY_CAPACITY = 64;

还有最重要的节点内部类Node

	// 内部类标识一个个节点
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }
  • hash(Obeject key)

    • jdk_1.8之前 扰动四次效率相对低下

      	final int hash(Object k) {
        int h = hashSeed;
        if (0 != h && k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h ^= k.hashCode();
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    • jdk_1.8及之后 只扰动一次提高效率

    	    static final int hash(Object key) {
	        int h;
	        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
 		}

初始化

  • 无参构造
	 /**
     * 无参构造
     * 默认初始大小16 负载因子 0.75
     */
    public HashMap() {
        this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
    }
  • 有参构造
	/**
     * 指定初始化大小, 默认负载因子 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);
    }

/**
 * 根据传入的map初始化新的map
 */
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

数据操作

添加元素 put(K, V)

	/**
     * 添加值
     */
    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

	final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // table未初始化 或者 长度为零
        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;
            // 新增的数据的key和旧的桶中第一个元素的key进行比较  hash一致并且key相等
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                // 将桶中第一个元素赋值给e
                e = p;
            // hash值不相等 判断是不是树类型
            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);
                        // 如果长度大于 链表转红黑树的阈值 - 1
                        // -1的原因是新的数据还没有计算进去
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 链表转树
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 如果hash一致key相等
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    // 把节点元素替换成新增的
                    p = e;
                }
            }
            // 在桶中找到key一致的节点
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                // 返回旧值
                return oldValue;
            }
        }
        // 修改次数+1
        ++modCount;
        // 判断添加后是否需要扩容
        if (++size > threshold)
            resize();

        afterNodeInsertion(evict);
        // 如果没有找到相同的key返回null
        return null;
    }

	 /**
     * 调整大小
     */
    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        // 旧表table有值
        if (oldCap > 0) {
            // 旧表数据长度 >= map最大容量
            // 超过最大值就不在扩容
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 旧表数据长度 * 2 < map最大容量 && 旧表数据长度 >= 16
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 新表临界值 = 旧表临界值 * 2
                newThr = oldThr << 1; // double threshold
        }
        // 进入此分支说明旧表数据长度=0, 第一次存放数据
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        // 默认阈值和默认大小 第一次put
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        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;
        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;
    }

获取元素 get(K)

	/**
     * 根据key获得数据
     */
    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }

	/**
     * 根据hash和key获得node节点
     */
    final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        // table不为null 且 长度大于0 且 桶上有元素
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (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)
                    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;
    }

删除元素 remove(K)

	/**
     * 根据key删除元素
     */
    public V remove(Object key) {
        Node<K,V> e;
        // key 存在返回值, 不存在返回null
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

	 /**
     * 删除节点
     */
    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        // table不为null 且 长度大于0 且 桶上目标位置有元素
        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;
            // 第一个元素是否满足
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            // 链表中有其他元素
            else if ((e = p.next) != null) {
                // 元素节点是树类型
                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;
                // 修改次数+1
                ++modCount;
                // 长度-1
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

总结

HashMap jdk_1.8之前是 数组 + 链表, 1.8及之后 是数组 + 链表 + 红黑树,
允许空值空键, 2倍大小扩容, 线程不安全

chilx
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的HashMap源码分析
Palpitate_fx的博客
03-27 807
目录 HashMap的继承体系 什么是Map 哈希表 存储结构 HashMap的属性 Node内部类 HashMap的构造方法 数组容量的计算 put( K key,V value)方法 HashMap的扩容机制 HashMap新的数组的填充 HashMap的get操作 HashMap 中的红黑树 散列冲突解决方式 HashMap的继承体系 1.HashMap实现了Serializable接口，可以被序列化 2.HashMap实现了Cloneable接口，可..
Java集合系列之HashMap源码分析
08-27
Java集合系列之HashMap源码分析 Java集合系列之HashMap源码分析是Java集合系列中的一篇非常重要的文章，它详细介绍了Java集合系列之HashMap源码，具有很高的参考价值。下面我们将对HashMap源码进行详细的分析。 ...
Java集合之HashMap源码分析
程序员随笔
01-07 2297
  前面我们提到了集合，今天我们就具体来了解一下Java集合中具体的组成部分！   以下源码均为jdk1.7 HashMap概述 HashMap是基于哈希表的Map接口的非同步实现. 提供所有可选的映射操作, 并允许使用null值和null健. 此类不保证映射的顺序. 需要注意的是: HashMap不是同步的. 哈希表 哈希表定义: 哈希表是一种根据关键码去寻找值的数据映射结构...
Java集合之一—HashMap
热门推荐
深入浅出学JAVA
11-02 60万+
深入浅出学Java——HashMap 哈希表（hash table） 也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中的对应实现HashMap的实现原理进行讲解，然后会对JDK7的HashMap源码进行分析。 一、什么是哈希表 在讨论哈希表之前，我们先大概了解下其他数据结构在新增，...
java基础之HashMap源码分析
qq_41720578的博客
05-02 1614
1、 HashMap原理分析 1.1、 HashMap继承体系 HashMap继承体系源码 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable 1.2、Node数据结构分析 HashMap内部类Node的源码 //静态内部类 实现了Map.Entry这个接口 K key,V value 泛型 stat
java HashMap 源码分析（深度讲解）
Cyan_RA9的博客
03-27 1591
java 集合篇章——HashMap源码分析（非常详细）。
【 java 集合】HashMap源码分析
阿牛的博客
01-13 1020
HashMap的底层原理一直以来是面试必问的问题，本节将基于源码分析一下！jdk7版本的HashMap和jdk8的HsahMap底层原理不同，本文主要以jdk8里的HashMap来分析，最后会总结jdk7与jdk8中HashMap的底层原理，用来对比不同！
Java集合之HashMap分析和使用
世银的博客
02-25 389
一、概览 HashMap是最常用的集合之一，基于哈希表实现，用于存储键值对，从key映射到value，实现了Map接口 HashMap的几个特点： 允许 null key与null value ，也就是键值对均可为空 key 不能重复 HashMap是无序集合，无法保证元素的特定顺序 HashMap不是线程安全的 HashMap的get与put方法使用了hashCode() 和 equals(...
JAVA集合之HashMap
ABC1234567890ABM的博客
05-18 233
HashMap底层是数组+链表+红黑树，HashSet底层即是HashMap，在前面《JAVA集合之HashSet》已记录过，故此只做一些分析。 调用HashMap()的无参构造方法时，会初始化加载因子，并且此时table数组是null。 public HashMap() { this.loadFactor = 0.75F; } 当第一次向HashMap中添加元素时，会扩容到16，元素会存放在HashMap$Node对象中。我们知道HashMap是K-V的形式，其实最.
【java集合】HashMap源码分析
weixin_42410658的博客
12-23 1026
继承体系 重要的成员变量 /** * 默认数组初始值大小 * 0b 0001 左移四位 0b 1000 => 0d 16 */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 /** * 数组最大长度 */ static final int MAXIMUM_CAPACITY = 1 << 30; /**
Java HashMap 源码分析
BusyMonkey
07-17 976
https://www.cnblogs.com/chengxiao/p/6059914.html   哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑。本文会对java集合框架中的对应实现HashMap的实现原...
Java集合源码全面分析
09-02
在本文中，我们将全面分析Java集合框架的核心概念和实现细节。 首先，Java集合框架的基础是`Collection`接口，它是所有集合类的根接口，定义了集合的基本操作。`Collection`接口有两个重要的子接口：`List`和`Set`...
HashMap 源码分析
12-22
《HashMap 源码解析——JDK11版本》 HashMap是Java中广泛使用的非同步散列表，其设计和实现是高效且灵活的。在JDK1.8之前，HashMap的底层数据...理解HashMap的源码对于深入学习Java集合框架和数据结构具有重要意义。
深入理解Java之HashMap源码剖析
08-31
深入理解Java中的HashMap源码，有助于我们更好地掌握这个常用数据结构的工作原理。HashMap是Java集合框架的重要组成部分，它实现了Map接口，提供了一种快速查找、插入和删除元素的方式。本文将详细解析HashMap的内部...
java集合类源码分析之Set详解
08-29
Java集合类源码分析之Set详解 Java集合类中的Set Interface是用于存储无序、不可重复元素的集合接口。Set Interface继承自Collection Interface，提供了基本的集合操作，如add、remove、contains等。Set Interface...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 114
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 568
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
如何使用ssm实现模具制造企业订单跟踪管理系统+vue
最新发布
a253399414的博客
08-26 475
【代码】ssm模具制造企业订单跟踪管理系统+vue
基于jenkins部署maven项目
静水深流
08-26 185
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
深入解析Java集合框架：HashMap到LinkedHashMap
这是一份针对Java集合框架深入学习的指南，特别关注了JDK7版本的源码分析。作者通过一系列的文章，详细讲解了不同集合类的实现原理，旨在帮助读者理解其中的设计思想并掌握如何在实际开发中合理选择和使用集合。 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值