Java8的集合：HashMap的实现原理

2024-06-23 02:18
文章标签 java hashmap 集合 原理 实现

本文主要是介绍Java8的集合：HashMap的实现原理，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

概述

  • 哈希表是基于 Map 接口的实现的，它允许 null 值和null 键，它不是线程同步的，同时也不保证有序。
  • Map的这种实现方式为 get（取）和 put（存）带来了比较好的性能。但是如果涉及到大量的遍历操作的话，就尽量不要把 capacity 设置得太高（或 load factor 设置得太低），否则会严重降低遍历的效率。
  • 影响 HashMap 性能的两个重要参数：initial capacity（初始化容量）和load factor（负载因子）。简单来说，容量就是哈希表桶的个数，负载因子就是键值对个数与哈希表长度的一个比值，当比值超过负载因子之后，HashMap 就会进行 rehash操作来进行扩容。
  • HashMap 的大致结构如下图所示，其中哈希表是一个数组，我们经常把数组中的每一个节点称为一个桶，哈希表中的每个节点都用来存储一个键值对。在插入元素时， 如果发生冲突（即多个键值对映射到同一个桶上）的话，就会通过链表的形式来解决冲突。因为一个桶上可能存在多个键值对，所以在查找的时候，会先通过 key 的哈希值先定位到桶，再遍历桶上的所有键值对，找出 key 相等的键值对，从而来获取 value。

在这里插入图片描述

属性

/*** 默认的初始容量为16*/static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16/*** 最大的容量上限为2^30*/static final int MAXIMUM_CAPACITY = 1 << 30;/*** 默认的加载因子为0.75*/static final float DEFAULT_LOAD_FACTOR = 0.75f;/*** 桶的树化阈值：即 链表转成红黑树的阈值，* 在存储数据时，当链表长度 > 该值时，则将链表转换成红黑树*/static final int TREEIFY_THRESHOLD = 8;/***桶的链表还原阈值：即 红黑树转为链表的阈值，当在扩容（resize（））时（此时HashMap的数据存储位置会*重新计算），在重新计算存储位置后，当原有的红黑树内数量 < 6时，则将 红黑树转换成链表 **/static final int UNTREEIFY_THRESHOLD = 6;/*** 最小树形化容量阈值：即 当哈希表中的容量 > 该值时，才允许树形化链表 （即 将链表 转换成红黑树）* 否则，若桶内元素太多时，则直接扩容，而不是树形化* 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD*/static final int MIN_TREEIFY_CAPACITY = 64;/*** 哈希表*/transient Node<K, V>[] table;   /*** 哈希表中键值对的个数*/transient int size;/*** 哈希表被修改的次数*/transient int modCount;/*** 它是通过 capacity*load factor 计算出来的，当 size 到达这个值时， 就会进行扩容操作*/int threshold;/*** 加载因子*/final float loadFactor;

下面是Node类的定义，它是HashMap中的一个静态内部类，哈希表中的每一个节点都是Node类型。我们可以看到，Node类中有4个属性，其中除了key和value之外，还有hash和next两个属性。hash是用来存储key的哈希值的，next是在构建链表时用来指向后继节点的。

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;}}

方法

get方法

实现步骤大致如下：
1、通过 hash 值获取该 key 映射到的桶。
2、桶上的 key 就是要查找的 key，则直接命中。
3、桶上的 key 不是要查找的 key，则查看后续节点：
（1）如果后续节点是树节点，通过调用树的方法查找该 key。
（2）如果后续节点是链式节点，则通过循环遍历链查找该 key。

/*** get方法主要调用的是getNode方法*/public V get(Object key) {Node<K, V> e;return (e = getNode(hash(key), key)) == null ? null : e.value;}final Node<K, V> getNode(int hash, Object key) {Node<K, V>[] tab, first, e;int n; K k;// 如果哈希表不为空&&key对应的桶上不为空if ((tab = table) != null && (n = tab.length) > 0 &&(first = tab[(n - 1) & hash]) != null) {// 是否直接命中if (first.hash == hash &&((k = first.key) == key || (key != null && key.equals(k))))return first;// 判断是否有后续节点if ((e = first.next) != null) {// 如果当前的桶是采用红黑树处理冲突，则调用红黑树的get方法去获取节点if (first instanceof TreeNode)return ((TreeNode<K, V>) first).getTreeNode(hash, key);// 不是红黑树的话，采用传统的链式结构，通过循环的方法判断链中是否存在该keydo {if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))return e;} while ((e = e.next) != null);}}return null;}
put方法

put 方法比较复杂，实现步骤大致如下：

  1. 先通过 hash 值计算出 key 映射到哪个桶。
  2. 如果桶上没有碰撞冲突，则直接插入。
  3. 如果出现碰撞冲突了，则需要处理冲突：
    • 如果该桶使用红黑树处理冲突，则调用红黑树的方法插入
    • 否则采用传统的链式方法插入。如果链的长度到达临界值，则把链转变为 红黑树
  4. 如果桶中存在重复的键，则为该键替换新值
  5. 如果 size 大于阈值，则进行扩容
/***put 方法的具体实现也是在 putVal 方法中，所以我们重点看下面的 putVal 方法*/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)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重复，则就是要找的节点if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;//如果是采用红黑树的方式处理冲突，则通过红黑树的putTreeVal方法去插入这个键值对else if (p instanceof TreeNode)e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);else {//否则就是传统的链式结构//采用循环遍历的方式，判断链中是否有重复的keyfor (int binCount = 0; ; ++binCount) {//到了链尾还没有找到重复的key，则说明HashMap没有包含该键if ((e = p.next) == null) {// 创建一个新节点插入到尾部p.next = newNode(hash, key, value, null);// 如果链的长度大于TREEIFY_THRESHOLD这个临界值，则把链变成红黑树if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1sttreeifyBin(tab, hash);break;}// 找到了重复的keyif (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;}}// 表示在上面的操作中找到了重复的键，所以这里把该键的值替换为新值if (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e);return oldValue;}}++modCount;// 判断是否需要进行扩容if (++size > threshold)resize();afterNodeInsertion(evict);return null;}
remove方法
/*** remove 方法的具体实现在 removeNode 方法中，所以我们重点看下面的 removeNode 方法* @param key* @return*/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, p; int n, index;// 如果当前key映射到的桶不为空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;//如果桶上的节点就是要找的key，则直接命中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);}}//比对找到的key的value跟要删除的是否匹配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;elsep.next = node.next;++modCount;--size;afterNodeRemoval(node);return node;}}return null;}
hash方法

在get 方法和 put 方法中都需要先计算 key 映射到哪个桶上，然后才进行之后的操作，计算的主要代码如下：

(n - 1) & hash

上面代码中的 n 指的是哈希表的大小，hash 指的是 key 的哈希值，hash 是通过下面这个方法计算出来的，采用了二次哈希的方式，其中 key 的 hashCode 方法是一个native 方法：

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

这个 hash 方法先通过 key 的 hashCode 方法获取一个哈希值，再拿这个哈希值与它的高 16 位的哈希值做一个异或操作来得到最后的哈希值，计算过程可以参考下图。为啥要这样做呢？

注释中是这样解释的：如果当 n 很小，假设为 64 的话，那么 n-1即为 63（0x111111），这样的值跟 hashCode()直接做与操作，实际上只使用了哈希值的后 6 位。如果当哈希值的高位变化很大，低位变化很小，这样就很容易造成冲突了，所以这里把高低位都利用起来，从而解决了这个问题

在这里插入图片描述

正是因为与的这个操作，决定了 HashMap 的大小只能是 2 的幂次方，想一想，如果不是 2 的幂次方，会发生什么事情？即使你在创建 HashMap 的时候指定了初始大小，HashMap 在构建的时候也会调用下面这个方法来调整大小：

static final int tableSizeFor(int cap) {int n = cap - 1;n |= n >>> 1;n |= n >>> 2;n |= n >>> 4;n |= n >>> 8;n |= n >>> 16;return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;}

这个方法的作用看起来可能不是很直观，它的实际作用就是把 cap 变成第一个大于等于 2 的幂次方的数。例如，16 还是 16，13 就会调整为 16，17 就会调整为 32

关于HashMap初始容量的相关疑问

HashMap是根据key的hash值决策key放入到哪个桶（bucket）中，通过 tab=[(n - 1) & hash] 公式计算得出。其中tab是一个哈希表

为什么要保证 capacity 是2的次幂呢？
  • 在get方法实现中，实际上是匹配链表中的 Node[] tab 中的数据。(n - 1) & hash实际上是计算出 key 在 tab 中索引位置，当key的hash没有冲突时，key在HashMap存储的位置就是匹配的node中的第一个节点。如果hash有冲突，就会在node里面节点中查询，直至匹配到相等的key。
  • 因为 n 永远是2的次幂，所以 n-1 通过二进制表示，永远都是尾端以连续1的形式表示（00001111，00000011），当(n - 1) 和 hash 做与运算时，会保留hash中 后 x 位的 1，例如 00001111 & 10000011 = 00000011
  • 这样做有2个好处
    • &运算速度快，至少比%取模运算块
    • 能保证 索引值 肯定在 capacity 中，不会超出数组长度
    • (n - 1) & hash，当n为2次幂时，会满足一个公式：(n - 1) & hash = hash % n
为啥非得是2的幂次方 ，2的倍数不行么，奇数不行么？

结合源码加网上相关的资料，解释如下

  • 奇数不行的解释很能被接受，在计算hash的时候，确定落在数组的位置的时候，计算方法是(n - 1) & hash ，奇数n-1为偶数，偶数2进制的结尾都是0，经过&运算末尾都是0，会增加hash冲突。
  • 为啥要是2的幂，不能是2的倍数么，比如6，10？hashmap 结构是数组，每个数组里面的结构是node（链表或红黑树），正常情况下，如果你想放数据到不同的位置，肯定会想到取余数确定放在那个数据里， 计算公式： hash % n，这个是十进制计算。在计算机中， (n - 1) & hash，当n为2次幂时，会满足一个公式：(n - 1) & hash = hash % n，计算更加高效。
  • 只有是2的幂数的数字经过n-1之后，二进制肯定是 …11111111 这样的格式，这种格式计算的位置的时候，完全是由产生的hash值类决定，而不受n-1 影响。你可能会想，受影响不是更好么，又计算了一下 ，hash冲突可能更低了，这里要考虑到扩容了，2的幂次方*2，在二进制中比如4和8，代表2的2次方和3次方，他们的2进制结构相 似,比如4和8 00000100 0000 1000 只是高位向前移了一位，这样扩容的时候，只需要判断高位hash,移动到之前位置的倍数就可以了，免去了重新计算位置的运算。
为什么要通过 (n - 1) & hash 决定桶的索引呢？
  • key具体应该在哪个桶中，肯定要和key挂钩的，HashMap顾名思义就是通过hash算法高效的把存储的数据查询出来，所以HashMap的所有get 和 set 的操作都和hash相关。
  • 既然是通过hash的方式，那么不可避免的会出现hash冲突的场景。hash冲突就是指 2个key 通过hash算法得出的哈希值是相等的。hash冲突是不可避免的，所以如何尽量避免hash冲突，或者在hash冲突时如何高效定位到数据的真实存储位置就是HashMap中最核心的部分
  • 首先要提的一点是 HashMap 中 capacity 可以在构造函数中指定，如果不指定默认是2 的 (n = 4) 次方，即16
  • HashMap中的hash也做了比较特别的处理，(h = key.hashCode()) ^ (h >>> 16)
    • 先获得key的hashCode的值 h，然后 h 和 h右移16位 做异或运算
    • 实质上是把一个数的低16位与他的高16位做异或运算，因为在前面 (n - 1) & hash 的计算中，hash变量只有末x位会参与到运算。使高16位也参与到hash的运算能减少冲突。
      • 例如1000000的二进制是 00000000 00001111 01000010 01000000
      • 右移16位： 00000000 00000000 00000000 00001111
      • 异或 00000000 00001111 01000010 01001111
capacity 永远都是 2 次幂，那么如果我们指定 initialCapacity 不为 2次幂时呢，是不是就破坏了这个规则？
  • 答案是不会的，HashMap的tableSizeFor方法做了处理，能保证n永远都是2次幂。
/*** Returns a power of two size for the given target capacity.*/
static final int tableSizeFor(int cap) {//cap-1后，n的二进制最右一位肯定和cap的最右一位不同，即一个为0，一个为1，例如cap=17（00010001），n=cap-1=16（00010000）int n = cap - 1;//n = (00010000 | 00001000) = 00011000n |= n >>> 1;//n = (00011000 | 00000110) = 00011110n |= n >>> 2;//n = (00011110 | 00000001) = 00011111n |= n >>> 4;//n = (00011111 | 00000000) = 00011111n |= n >>> 8;//n = (00011111 | 00000000) = 00011111n |= n >>> 16;//n = 00011111 = 31//n = 31 + 1 = 32, 即最终的cap = 32 = 2 的 (n=5)次方return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

小结

  • 在这里有一个需要注意的地方，有些文章指出当哈希表的桶占用超过阈值时就进行扩容，这是不对的；实际上是当哈希表中的键值对个数超过阈值时，才进行扩容的。
  • 按照原来的拉链法来解决冲突，如果一个桶上的冲突很严重的话，是会导致哈希表的效率降低至 O（n），而通过红黑树的方式，可以把效率改进至 O（logn）。相比链式结构的节点，树型结构的节点会占用比较多的空间，所以这是一种以空间换时间的改进方式

这篇关于Java8的集合：HashMap的实现原理的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1086038。

相关文章

C++对象布局及多态实现探索之内存布局（整理的很多链接）

C++对象布局及多态实现探索之内存布局（整理的很多链接）

本文通过观察对象的内存布局，跟踪函数调用的汇编代码。分析了C++对象内存的布局情况，虚函数的执行方式，以及虚继承，等等 文章链接：http://dev.yesky.com/254/2191254.shtml      论C/C++函数间动态内存的传递 (2005-07-30)   当你涉及到C/C++的核心编程的时候，你会无止境地与内存管理打交道。 文章链接：http://dev.yesky
阅读更多...
Java五子棋之坐标校正

Java五子棋之坐标校正

上篇针对了Java项目中的解构思维，在这篇内容中我们不妨从整体项目中拆解拿出一个非常重要的五子棋逻辑实现：坐标校正，我们如何使漫无目的鼠标点击变得有序化和可控化呢？ 目录 一、从鼠标监听到获取坐标 1.MouseListener和MouseAdapter 2.mousePressed方法 二、坐标校正的具体实现方法 1.关于fillOval方法 2.坐标获取 3.坐标转换 4.坐
阅读更多...
Spring Cloud：构建分布式系统的利器

Spring Cloud：构建分布式系统的利器

引言 在当今的云计算和微服务架构时代，构建高效、可靠的分布式系统成为软件开发的重要任务。Spring Cloud 提供了一套完整的解决方案，帮助开发者快速构建分布式系统中的一些常见模式（例如配置管理、服务发现、断路器等）。本文将探讨 Spring Cloud 的定义、核心组件、应用场景以及未来的发展趋势。 什么是 Spring Cloud Spring Cloud 是一个基于 Spring
阅读更多...
Javascript高级程序设计(第四版)--学习记录之变量、内存

Javascript高级程序设计(第四版)--学习记录之变量、内存

原始值与引用值 原始值：简单的数据即基础数据类型，按值访问。 引用值：由多个值构成的对象即复杂数据类型，按引用访问。 动态属性 对于引用值而言，可以随时添加、修改和删除其属性和方法。 let person = new Object();person.name = 'Jason';person.age = 42;console.log(person.name,person.age);//'J
阅读更多...
java8的新特性之一（Java Lambda表达式）

java8的新特性之一（Java Lambda表达式）

1：Java8的新特性 Lambda 表达式： 允许以更简洁的方式表示匿名函数（或称为闭包）。可以将Lambda表达式作为参数传递给方法或赋值给函数式接口类型的变量。 Stream API： 提供了一种处理集合数据的流式处理方式，支持函数式编程风格。 允许以声明性方式处理数据集合（如List、Set等）。提供了一系列操作，如map、filter、reduce等，以支持复杂的查询和转
阅读更多...
Java面试八股之怎么通过Java程序判断JVM是32位还是64位

Java面试八股之怎么通过Java程序判断JVM是32位还是64位

怎么通过Java程序判断JVM是32位还是64位 可以通过Java程序内部检查系统属性来判断当前运行的JVM是32位还是64位。以下是一个简单的方法： public class JvmBitCheck {public static void main(String[] args) {String arch = System.getProperty("os.arch");String dataM
阅读更多...
详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

详细分析Springmvc中的@ModelAttribute基本知识（附Demo）

目录 前言1. 注解用法1.1 方法参数1.2 方法1.3 类 2. 注解场景2.1 表单参数2.2 AJAX请求2.3 文件上传 3. 实战4. 总结 前言 将请求参数绑定到模型对象上，或者在请求处理之前添加模型属性 可以在方法参数、方法或者类上使用 一般适用这几种场景： 表单处理：通过 @ModelAttribute 将表单数据绑定到模型对象上预处理逻辑：在请求处理之前
阅读更多...
eclipse运行springboot项目，找不到主类

eclipse运行springboot项目，找不到主类

解决办法尝试了很多种，下载sts压缩包行不通。最后解决办法如图： help--->Eclipse Marketplace--->Popular--->找到Spring Tools 3---->Installed。
阅读更多...
JAVA读取MongoDB中的二进制图片并显示在页面上

JAVA读取MongoDB中的二进制图片并显示在页面上

1：Jsp页面： <td><img src="${ctx}/mongoImg/show"></td> 2：xml配置： <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001
阅读更多...
Java面试题：通过实例说明内连接、左外连接和右外连接的区别

Java面试题：通过实例说明内连接、左外连接和右外连接的区别

在 SQL 中，连接（JOIN）用于在多个表之间组合行。最常用的连接类型是内连接（INNER JOIN）、左外连接（LEFT OUTER JOIN）和右外连接（RIGHT OUTER JOIN）。它们的主要区别在于它们如何处理表之间的匹配和不匹配行。下面是每种连接的详细说明和示例。 表示例 假设有两个表：Customers 和 Orders。 Customers CustomerIDCus
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2