JDK8-HashMap源码浅析

最新推荐文章于 2023-08-28 14:21:52 发布
最新推荐文章于 2023-08-28 14:21:52 发布
阅读量142 收藏
点赞数
分类专栏： java源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45149504/article/details/118049335
版权
本文详细介绍了HashMap的内部实现，包括其在JDK1.7及之前的数组+链表结构和JDK8引入的红黑树优化。HashMap通过计算键的哈希值来决定存储位置，解决哈希碰撞问题。文章还展示了HashMap的源码，包括构造函数、put、get和remove等关键操作，并探讨了哈希码计算中乘以31的原因。
摘要由CSDN通过智能技术生成

总叙

HashMap是Map接口下一个实现，提供键值对的存储。JDK1.7及以前通过数组+链表实现数据的存储，而JDK8开始加入了红黑树，存储结构做了优化，即存在两种存储方式：数组+链表或数组+红黑树。

如何实现存储

在开始之前可以先看看Hash表的相关内容。

  1. Hash表：理解为一个包含了多个格子的表，每个格子存放不同hash值的元素。例如格子1存放hash值为50的对象、格子2存放hash值为100的对象…
  2. Hash碰撞：不同的值计算出的Hash值一般情况下应该是不一样的，因而会存放到Hash表中的不同格子。但是如果把数据量放大到一定的数量级，就会出现不同的对象计算出来得Hash值相同，因此Hash表中的同一个格子可能同时存在多个元素，这就叫Hash碰撞。也可以借此说明Java中hash值相同的两个对象不一定是同一个对象，但是同一个对象的hash值一定是相同的。只有hash值和equals都true的时候才能说明是同一个对象。

了解了Hash表后再来看HashMap就清晰多了。如何决定将哪个链表插入到数组哪个位置，其实精髓就是HashMap为什么有个Hash，因为借助于Hash表来实现，即对要存储的key进行Hash值计算，通过一定逻辑的转换得到下标的值，于是将该key对应的value存放到数组的该下标位置。按照这种逻辑不断地进行存储，势必会出现多个key计算的下标位置相同，而数组的该下标位置已经有元素了。于是为了解决“碰撞”问题，HashMap通过链表来存储计算后下标相同的元素，然后将链表的头结点放到数组中，通过节点不断指向解决“碰撞”。
在这里插入图片描述
这是数组+链表的存储方式；数组+红黑树的方式只是将链表换成红黑树即可（红黑树也是基于链表的结构）

源码

类继承图

在这里插入图片描述

内部类链表实现

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;// 计算hash值
    final K key;// 用来计算hash的键
    V value;// 存储的值
    Node<K,V> next;// 指向下一个节点（形成链表）
    ...
}

字段

// 序列化id
private static final long serialVersionUID = 362498820763181265L;
// 默认初始化容量：16
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;
// 最小红黑树化容量
static final int MIN_TREEIFY_CAPACITY = 64;
// 链表数组
transient Node<K,V>[] table;
// 可以用来获取迭代器
transient Set<Map.Entry<K,V>> entrySet;
// HashMap实际存储的键值对的个数
transient int size;
// 用来记录该Has和Map存在的结构化的修改次数(键值对数量变化和reHash时候会记录）
// 字段用于检查线程不安全，提供快速失败机制
transient int modCount;
// 下一次扩容后的size，本次处罚扩容的阈值
int threshold;
// 负载因子
final float loadFactor;

构造方法

  • 带初始容量和负载因子的构造
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);
}
  • 只带初始化容量（使用默认负载因子）的构造
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
  • 无参构造（全使用默认）
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
  • 带Map参数的构造方法（常用于需要一个相同键值对，但是一个全新的HashMap的情况）
public HashMap(Map<? extends K, ? extends V> m) {
	// 使用默认的负载（0.75）
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    // 赋值
    putMapEntries(m, false);
}

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
	// 获取原map的大小
    int s = m.size();
    if (s > 0) {
    	// 通过构造进来的时候，table还是null
        if (table == null) { 
        	// 计算出刚好未达到负载阈值
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY);
            if (t > threshold)
            	// 拿到一个比t大而且是2的幂的数，如t=10，返回16,通过不断地移位来完成
                threshold = tableSizeFor(t); 
        }
        else if (s > threshold)
            resize();
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
             // 通过循环不断将旧map的映射赋值到新的map
            putVal(hash(key), key, value, false, evict);
        }
    }
}

// 假设cap为10
static final int tableSizeFor(int cap) {
    int n = cap - 1; // n = 9 1001
    n |= n >>> 1; // n = (n | (n >>> 1)) = (1001 | 0100) = 1101 = 13
    n |= n >>> 2; // n = (n | (n >>> 2)) = (1101 | 0011) = 1110 = 15
    n |= n >>> 4; // n = (n | (n >>> 4)) = (1110 | 0000) = 1110 = 15
    n |= n >>> 8; // n = (n | (n >>> 4)) = (1110 | 0000) = 1110 = 15
    n |= n >>> 16; // n = (n | (n >>> 4)) = (1110 | 0000) = 1110 = 15
    // 返回n + 1 = 16
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; 
}

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)
    	// 已经初始化完成，获取size
        n = (tab = resize()).length;
        // 计算出（根据key计算出的hash值）& （n-1) 计算出下标,并做null判断
    if ((p = tab[i = (n - 1) & hash]) == null)
    	// 为null则进行赋值
        tab[i] = newNode(hash, key, value, null); 
    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;
        }
    }
    // 将修改记录+1
    ++modCount;
    // 判断是否需要扩容
    if (++size > threshold) 
        resize();
    afterNodeInsertion(evict);
    return null;
}

常用API

往HashMap中存值

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;
        if ((tab = table) == null || (n = tab.length) == 0)// 当table未被初始化，则进行初始化
            n = (tab = resize()).length;// 已经初始化完成，获取size
        if ((p = tab[i = (n - 1) & hash]) == null)// 计算出（根据key计算出的hash值）& （n-1) 计算出下标,并做null判断
            tab[i] = newNode(hash, key, value, null); // 为null则进行赋值
        else {// 当前位置不是null（已经存在值）
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;// 键相同，hash值相同，值也相同，直接覆盖（如果为null，则首先是用链表存储的）
            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) // 判断是否达到转红黑树条件
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;// 如果hash值相同且键也相同，则直接覆盖
                    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;// 将修改记录+1
        if (++size > threshold) // 判断是否需要扩容
            resize();
        afterNodeInsertion(evict);
        return null;
    }
  • 从HashMap中取值
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 = 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;
}
  • 按照key删除元素
public V remove(Object key) {
    Node<K,V> e;
    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;
    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;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}
  • 清空HashMap
public void clear() {
    Node<K,V>[] tab;
    modCount++;
    if ((tab = table) != null && size > 0) {// 检查map是否为空
        size = 0;
        for (int i = 0; i < tab.length; ++i)// 只需将数组全部置为nul，待GC完成回收
            tab[i] = null;
    }
}
  • 判断是否包含value
public boolean containsValue(Object value) {
    Node<K,V>[] tab; V v;
    if ((tab = table) != null && size > 0) {
        for (int i = 0; i < tab.length; ++i) {// 遍历数组
            for (Node<K,V> e = tab[i]; e != null; e = e.next) {// 遍历链表
                if ((v = e.value) == value ||
                    (value != null && value.equals(v)))
                    return true;
            }
        }
    }
    return false;
}
  • 判断是否包含键
public boolean containsKey(Object key) {
    return getNode(hash(key), key) != null;
}

细节关注

hashCode方法中的为什么要乘以一个常数？
public int hashCode() {
    int h = hash;
    if (h == 0 && value.length > 0) {
        char val[] = value;

        for (int i = 0; i < value.length; i++) {
            h = 31 * h + val[i];
        }
        hash = h;
    }
    return h;
}

首先乘以一个数，可以散列hash值，而乘以31是一个统计结果，该数字下的hash碰撞较少，所以直接写死了。

大聪明教你学Java | 在 JDK8 中 HashMap 是如何实现的
不肯过江东丶
03-22 4722
相信各位小伙伴都有感觉，我们去十家公司面试，八家都会问到关于 HashMap 的知识，由此就可以看出 HashMap 的重要性了，那么今天就跟大家深入浅出了聊一聊 HashMap 是如何实现的。
HashMap源码浅析
hello world
08-19 321
HashMap源码分析 本文参照了黑马程序员的HashMap视频 HashMap集合简介 HashMap是基于基于哈希表的 Map 接口的实现。允许使用null值和null键，是线程不安全的 JDK1.8之前HashMap由数组+链表组成，数组为主题，链表是为了解决哈希冲突存在的。JDK1.8以后，当链表长度大于阈值（或者红黑树的边界值，默认值为8）并且当前数组的长度大于64时，此时此索引位置上的所有数据改为使用红黑树储存。 注：将链表转换为红黑树前会判断，即使阈值大于8，但是数组长度小于64，此时并不会将
【JAVA基础】JDK8 HashMap 源码深度解析
秀强的专栏
08-27 519
而且当 key 是 Integer 时且小于等于 65535 时，(h = key.hashCode())^ (h >>> 16) 和 key 的值是相等的，所以此时 key 是有序递增的。当 key 大于 65535 以后，高 16 位就不全是 0 了，(h = key.hashCode())^ (h >>> 16) 的值就与 key 不相等了。n = 16 时，(h ^ (h >>> 16)) & (n-1) = 5， 即计算出来的下标是 5。JDK8：数组 + 链表 + 红黑树。...
JDK8 HashMap源码解析
freak_csh的博客
07-16 435
JDK8 HashMap源码解析
【JavaSE】HashMap源码分析(jdk8)
weixin_46153050的博客
02-18 516
概述 HashMap本质是一个hash表，采用拉链法解决冲突，并且在某个位置的链表过长时将其转化为一棵二叉搜索树降低插入的开销； 按照以下顺序去阅读HashMap的源码是不错的选择 构造函数 put( )方法 remove( )方法 get( )方法 一、主要成员 1.1 成员属性 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Seriali
JDK8中的HashMap源码解析与理解
TankyZhang的博客
10-30 952
jdk8中的HashMap源码解析与理解 一、预备知识 关于hash： ​ 有个非常关键的特点，不定长度的输入固定长度的输出，将一个对象经过一定的hash算法映射成相同长度的hash值。 hash冲突的避免： ​ hash是无法完全避免的，只能通过各种方法手段尽量的减少hash冲突。 关于hash碰撞的解决方案： 开放地址法：假设一个数组有四个长度此时存放了[8,null,10,11,null]两个为null的位置代表没有数据，此时如果有个15来了，15mod 4=3那么这个15应该放在下标为3的位置上
JDK8的HashMap源码解析
如风的博客
05-31 352
hashMap底层数据结构 - JDK1.8 之前 底层 数组+链表，大量的元素都存放到同一个桶中时，这个桶下有一条长长的链表，极端情况HashMap 就相当于一个单链表，假如单链表有 n 个元素，遍历的时间复杂度就是 O(n) - JDK1.8 底层 数组+链表+红黑树 ，hash冲突后处理办法由原来的链表结构，引入了 红黑树 概念 - 重要对象 java.util.HashMap.Node 链表Node节点 java.util.HashMap.TreeNode TreeNode 红黑树 - 重要成员变量
java实现线程安全的hashmap_浅析JDK1.8 下HashMap线程安全性
weixin_31437143的博客
03-01 934
Java线程安全主要体现在3个方面：可见性、原子性、有序性。下文主要从原子性和可见性分析JDK 1.8 中HashMap的线程安全性及ConcurrentHashMap如何实现线程安全。HashMap中存在的线程安全问题：1.HashMap在读取Hash槽首元素的时候读取的是工作内存中引用所指向的对象，并发情况下，其他线程修改的值并不能被及时读取到。2.HashMap在插入新元素的时候，主要会进行...
【java集合】jdk1.8 HashMap源码浅析
XCXCXCXCX
04-20 278
    花了一些时间阅读了jdk1.8中的HashMap、LinkedHashMap、TreeMap和WeakHashMap的源码，整理一下学习到的东西，这篇博客主要写HashMap的实现源码，并次要总结一下另外三个map实现类的实现原理和特性。HashMap采用的数据结构首先介绍一个重要的参数TREEIFY_THRESHOLD，看一下官方备注。/** * The bin count t...
[JDK8] HashMap源码解析
不忘初心 方得始终
05-12 564
文章标题写在前面底层存储结构构造HashMaptableSizeFor(int cap)HashMap添加/更新hash(key)putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)treeifyBin(Node<K,V>[] tab, int hash)resize()HashMap删除HashMap查找线程安全 写在前面 HashMap的实现思想太有含金量了，方方面面都有值得细细品鉴的，想用一篇文章分析透彻
HashMap 源码详细分析(JDK1.8)
weixin_34178244的博客
01-22 695
1.概述 本篇文章我们来聊聊大家日常开发中常用的一个集合类 - HashMap。HashMap 最早出现在 JDK 1.2中，底层基于散列算法实现。HashMap 允许 null 键和 null 值，在计算哈键的哈希值时，null 键哈希值为 0。HashMap 并不保证键值对的顺序，这意味着在进行某些操作后，键值对的顺序可能会发生变化。...
HashMap源码解析（JDK8）
qq_57756904的博客
10-10 299
链表节点Node 这是一个静态内部类，用来存取value static class Node<K,V> implements Map.Entry<K,V> { final int hash;// 哈希值 final K key;// key V value;// value Node<K,V> next;// 链表后置节点 // 构造初始化 Node(i..
HashMap JDK8源码解析
qq_50596778的博客
11-05 333
HashMap -1.8 源码解析 简介： HashMap 主要用来存放键值对，它基于哈希表的 Map 接口实现，是常用的 Java 集合之一，是非线程安全的。 HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个 JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。 JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，
JDK8 HashMap源码
dreambyday
03-13 648
1 HashMap 1.1 常量 public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable { // 一个随机值，用于序列化 private static final long serialVersionUID = 362498820763181265L; /** * 无参初始化时HashMap的
JDK8HashMap源码
Jak的博客
04-11 329
一、红黑树 1.1 红黑树的定义 红黑树是一种自平衡的二叉查找树，它的节点的颜色为红色和黑色。它不严格控制左、右子树高度或节点数之差小于等于1。通过左旋、右旋、变色保证平衡 1.每个节点非红即黑； 2.根节点总是黑色的； 3.每个叶子节点都是黑色； 4.红节点的子节点一定是黑色的。 5.从任一节点到叶子节点必须包含相同数量的黑色节点。 AVL树是高度平衡的而红黑树不是高度平衡的，它只要求部分地达到平衡要求，结合变色，降低了对旋转的要求从而提高了性能。在最坏的情况下也可以保证O(logN)
深入jdk8 HashMap源码
qq_33030159的博客
02-28 138
https://blog.csdn.net/qq_38182963/article/details/78942764
JDK8 HashMap 源码解析
最新发布
axibazZ的博客
08-28 281
hashmap实现的核心方法源码解读
JDK8-HashMap底层源码解析(一)
q66562636的博客
06-02 212
HashMap提供了4个构造函数：tableSizeFor方法具体实现：我们可以通过反射来查看HashMap在初始化和put后容量和阈值的变化，代码如下： 输出结果如下：接下来我们看put方法：并没有直接使用key的hashcode方法来生成哈希值，而是执行了这个操作： (h = key.hashCode()) ^ (h >>> 16) ；在执行hashcode方法后再异或 这个右移16位的值，得到了一个新的哈希值，但是哈希冲突仍然不能避免。接着看putVal方法：treeifyBin方法会先判断Nod
JDK8中hashmap源码分析
weixin_41325595的博客
10-12 163
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 ...
自制Oracle Java8-JDK8-JRE8-u191绿色免安装版
根据提供的文件信息，本文将详细说明Java 8（JDK8、JRE8）的重要知识点，同时也会介绍绿色免安装版的概念和其相关操作。以下是对标题、描述和标签中所提及知识点的详细介绍。 ### JDK8/JRE8 Java Development Kit...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值