HashMap的容量与扩容

最新推荐文章于 2023-08-05 17:26:59 发布
最新推荐文章于 2023-08-05 17:26:59 发布
阅读量378 收藏
点赞数


有几个重要的常量：

<code class="language-java hljs  has-numbering"><span class="hljs-keyword">static</span> <span class="hljs-keyword">final</span> <span class="hljs-keyword">int</span> DEFAULT_INITIAL_CAPACITY = <span class="hljs-number">1</span> << <span class="hljs-number">4</span>;<span class="hljs-comment">//默认的桶数组大小</span>
<span class="hljs-keyword">static</span> <span class="hljs-keyword">final</span> <span class="hljs-keyword">int</span> MAXIMUM_CAPACITY = <span class="hljs-number">1</span> << <span class="hljs-number">30</span>;<span class="hljs-comment">//极限值（超过这个值就进行扩容）</span>
<span class="hljs-keyword">static</span> <span class="hljs-keyword">final</span> <span class="hljs-keyword">float</span> DEFAULT_LOAD_FACTOR = <span class="hljs-number">0.75</span>f;<span class="hljs-comment">//负载因子（请阅读下面体会这个值的用处）</span></code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li></ul>

（一）调用HashMap()构造方法

这个构造方法长这样：

<code class="language-java hljs  has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-title">HashMap</span>() {
        <span class="hljs-keyword">this</span>.loadFactor = DEFAULT_LOAD_FACTOR; <span class="hljs-comment">//设置一个默认的负载因子，默认为0.75，下面说它有啥用</span>
    }</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li></ul>

这就完了，然后用于hash的桶数组为null，当我们第一次put的时候，会到达这段代码：

<code class="language-java hljs  has-numbering">Node<K,V>[] tab; <span class="hljs-keyword">int</span> n;
    <span class="hljs-comment">//table就是桶数组，初始为null</span>
    <span class="hljs-keyword">if</span> ((tab = table) == <span class="hljs-keyword">null</span> || (n = tab.length) == <span class="hljs-number">0</span>)
        n = (tab = resize()).length;</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li></ul>

所以会进入resize()方法，到达这段代码：

<code class="language-java hljs  has-numbering"><span class="hljs-comment">//取消多余的代码，我直接贴上进入的这个分支的代码</span>
<span class="hljs-keyword">else</span> {
      newCap = DEFAULT_INITIAL_CAPACITY;
      newThr = (<span class="hljs-keyword">int</span>)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>

newCap的意思是：即将用于hash的桶数组的长度，这里的默认值是16
newThr的意思是：当桶中的键值对的个数超过这个值时就进行扩容，这时候上面提到的负载因子就起作用了，所以这里的newThr为0.75×16 = 12

所以经过这个默认构造方法，并且进行第一次put后，桶数组建立了，桶容量为16，极限值为12。

（二）调用HashMap(int initialCapacity)构造方法

<code class="language-java hljs  has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-title">HashMap</span>(<span class="hljs-keyword">int</span> initialCapacity) {
    <span class="hljs-comment">//这个方法实际调用另一个构造方法，所以这个构造方法就不分析了，直接看第三个的分析</span>
    <span class="hljs-keyword">this</span>(initialCapacity, DEFAULT_LOAD_FACTOR);
}</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li></ul>

（三）调用HashMap(int initialCapacity, float loadFactor)构造方法

<code class="language-java hljs  has-numbering"><span class="hljs-keyword">public</span> <span class="hljs-title">HashMap</span>(<span class="hljs-keyword">int</span> initialCapacity, <span class="hljs-keyword">float</span> loadFactor) {
    <span class="hljs-comment">//桶数组的大小小于0时抛异常</span>
    <span class="hljs-keyword">if</span> (initialCapacity < <span class="hljs-number">0</span>)
        <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> IllegalArgumentException(<span class="hljs-string">"Illegal initial capacity: "</span> +
                                               initialCapacity);
    <span class="hljs-comment">//如果桶数组的大小超过最大值，则简单的将桶容量修改为最大值2的30次方</span>
    <span class="hljs-keyword">if</span> (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    <span class="hljs-comment">//如果负载因子不符合规范，那么抛异常</span>
    <span class="hljs-keyword">if</span> (loadFactor <= <span class="hljs-number">0</span> || Float.isNaN(loadFactor))
        <span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> IllegalArgumentException(<span class="hljs-string">"Illegal load factor: "</span> +
                                               loadFactor);
    <span class="hljs-keyword">this</span>.loadFactor = loadFactor;
    <span class="hljs-comment">//这个意思是根据桶数组的大小求一个“极限值threshold”，当桶中的键值队个数超过这个大小就进行扩容</span>
    <span class="hljs-comment">//tableSizeFor方法求得的数字是刚超过initialCapacity的一个2的n次方的数，例如initialCapacity是1000，那么得到的threshold就是1024，这个方法很奇特，我没看懂，感兴趣的自己去研究。</span>
    <span class="hljs-keyword">this</span>.threshold = tableSizeFor(initialCapacity);
    }</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li></ul>

所以经过这个方法之后，桶容量确定了，极限值也确定了，但是桶数组还是null。
当第一次put时，触发如下代码：

<code class="language-java hljs  has-numbering"><span class="hljs-comment">//发现桶数组是null，所以需要新建一个桶数组</span>
<span class="hljs-keyword">if</span> ((tab = table) == <span class="hljs-keyword">null</span> || (n = tab.length) == <span class="hljs-number">0</span>)
    n = (tab = resize()).length;</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li></ul>

接着看resize()中触发了哪些代码：

<code class="language-java hljs  has-numbering">Node<K,V>[] oldTab = table;
<span class="hljs-keyword">int</span> oldCap = (oldTab == <span class="hljs-keyword">null</span>) ? <span class="hljs-number">0</span> : oldTab.length;<span class="hljs-comment">//看这里，oldCap会是0</span>
<span class="hljs-keyword">int</span> oldThr = threshold;<span class="hljs-comment">//看这里，oldThr不会是0，因为有tableSizeFor()方法，确保oldThr至少是1</span>
<span class="hljs-keyword">int</span> newCap, newThr = <span class="hljs-number">0</span>;
<span class="hljs-keyword">if</span> (oldCap > <span class="hljs-number">0</span>) {
    <span class="hljs-keyword">if</span> (oldCap >= MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        <span class="hljs-keyword">return</span> oldTab;
    }
    <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> ((newCap = oldCap << <span class="hljs-number">1</span>) < MAXIMUM_CAPACITY &&
            oldCap >= DEFAULT_INITIAL_CAPACITY)
        newThr = oldThr << <span class="hljs-number">1</span>; <span class="hljs-comment">// double threshold</span>
}
<span class="hljs-comment">//所以肯定会进入这个分支，将桶数组的大小改为极限值大小。然后在下面创建一个newCap大小的桶数组</span>
<span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> (oldThr > <span class="hljs-number">0</span>) <span class="hljs-comment">// initial capacity was placed in threshold</span>
    newCap = oldThr;</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li></ul>

然后还会进入下面这个分支：

<code class="language-java hljs  has-numbering"><span class="hljs-keyword">if</span> (newThr == <span class="hljs-number">0</span>) {
            <span class="hljs-keyword">float</span> ft = (<span class="hljs-keyword">float</span>)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (<span class="hljs-keyword">float</span>)MAXIMUM_CAPACITY ?
                      (<span class="hljs-keyword">int</span>)ft : Integer.MAX_VALUE);
        }</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>

这个分支会按负载因子设置极限值

（四）超过极限值后的扩容

在每次put之后，会有下面这个判断：

<code class="language-java hljs  has-numbering"><span class="hljs-keyword">if</span> (++size > threshold)
    resize();</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li></ul>

就是说超过极限值时会进行扩容，扩容方式如下：

<code class="language-java hljs  has-numbering">Node<K,V>[] oldTab = table;
<span class="hljs-keyword">int</span> oldCap = (oldTab == <span class="hljs-keyword">null</span>) ? <span class="hljs-number">0</span> : oldTab.length;
<span class="hljs-keyword">int</span> oldThr = threshold;
<span class="hljs-keyword">int</span> newCap, newThr = <span class="hljs-number">0</span>;
<span class="hljs-comment">//肯定会进入这个分支</span>
<span class="hljs-keyword">if</span> (oldCap > <span class="hljs-number">0</span>) {
    <span class="hljs-keyword">if</span> (oldCap >= MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        <span class="hljs-keyword">return</span> oldTab;
    }
    <span class="hljs-comment">//如果我们是这样调用：HashMap(7，任意满足条件的值），那么经过第一次调用put()会初始化桶数组的大小和极限值一样，这里即为8。所以这里不会进入这个分支，但是newCap会变为16</span>
    <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> ((newCap = oldCap << <span class="hljs-number">1</span>) < MAXIMUM_CAPACITY &&
            oldCap >= DEFAULT_INITIAL_CAPACITY)
        newThr = oldThr << <span class="hljs-number">1</span>; <span class="hljs-comment">// double threshold</span>
}
<span class="hljs-comment">//所以会进入这里</span>
<span class="hljs-keyword">if</span> (newThr == <span class="hljs-number">0</span>) {
    <span class="hljs-keyword">float</span> ft = (<span class="hljs-keyword">float</span>)newCap * loadFactor;
    newThr = (newCap < MAXIMUM_CAPACITY && ft < (<span class="hljs-keyword">float</span>)MAXIMUM_CAPACITY ?
            (<span class="hljs-keyword">int</span>)ft : Integer.MAX_VALUE);
}
threshold = newThr;<span class="hljs-comment">//计算的出这里的threshold即极限值会由刚才的8变为12（和负载因子大小有关）</span></code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li></ul>

接上面这个例子，下一次扩容会如何？

<code class="language-java hljs  has-numbering"><span class="hljs-keyword">if</span> (oldCap > <span class="hljs-number">0</span>) {
    <span class="hljs-keyword">if</span> (oldCap >= MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        <span class="hljs-keyword">return</span> oldTab;
    }
    <span class="hljs-comment">//因为桶容量变为了16，所以这次会进入这个分支，桶容量和极限值都会加倍。</span>
    <span class="hljs-keyword">else</span> <span class="hljs-keyword">if</span> ((newCap = oldCap << <span class="hljs-number">1</span>) < MAXIMUM_CAPACITY &&
            oldCap >= DEFAULT_INITIAL_CAPACITY)
        newThr = oldThr << <span class="hljs-number">1</span>; <span class="hljs-comment">// double threshold</span>
}</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li></ul>

直到…………
当桶容量加倍到最大值会怎么样？

<code class="language-java hljs  has-numbering"><span class="hljs-comment">//因为每次都是加倍，所以最终肯定会加倍到MAXIMUM_CAPACITY，会进入这个分支。</span>
<span class="hljs-keyword">if</span> (oldCap >= MAXIMUM_CAPACITY) {
    threshold = Integer.MAX_VALUE;
    <span class="hljs-keyword">return</span> oldTab;
}</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li></ul>

桶容量变为最大值时，紧接着的一次扩容只是简单的将极限值修改为Integer.MAX_VALUE。桶数组大小并不会继续加倍

（五）如果HashMap中的键值对数量超过Integer.MAX_VALUE了呢？

我们仔细看一下这段代码：

<code class="language-java hljs  has-numbering">这个size类型是<span class="hljs-keyword">int</span>，那么最大就是Integer.MAX_VALUE，所以不会有++size > threshold的情况，往后都不会进行扩容了。
<span class="hljs-keyword">if</span> (++size > threshold)
    resize();</code>
hyj 小猴子
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java HashMap扩容详解及实例代码
08-31
Java中的HashMap是一个非常重要的数据结构...在处理大量数据时，合理地设置HashMap的初始容量和加载因子可以显著降低扩容的频率，从而提高整体的运行效率。希望本文的讲解能帮助你更好地理解和运用HashMap的扩容功能。
HashMap源码粗略解读（面试必问）
12-21
同时，`loadFactor`是扩容因子，其默认值是0.75f，即当Map的元素数量达到容量的75%时，HashMap会触发扩容。 2. **HashMap如何扩容** 当HashMap中的元素数量达到当前容量的`loadFactor`（默认0.75f）时，会进行扩容...
hashmap原理以及扩容
yulungggg的博客
07-06 2119
hashmap扩容......................................................................................................................1 1. equals和hashcode........................................................
hashMap的扩容
麋鹿麋鹿迷了路
04-11 518
一、扩容时机： 1、HashMap使用的是懒加载，构造完HashMap对象后，只要不进行put 方法插入元素之前，HashMap并不会去初始化或者扩容table。 2、当进行put的时候发现hashMap的容量达到阈值Capacity*loadFactor时发生扩容且当前加入的数据引起hash冲突 因为上面这两个条件，所以存在下面这些情况： （1）、就是hashmap在存值的时候（默...
ArrayList及HashMap的扩容规则讲解
08-26
HashMap的扩容规则是将当前容量扩展到大于oldCapacity的最小的2的n次方整数。这种扩容规则可以避免哈希冲突，提高HashMap的查找效率。 在HashMap的源代码中，我们可以看到addEntry方法，该方法用于添加新的键值对到...
java中hashmap容量的初始化实现
08-25
"Java中HashMap容量的初始化实现" Java中HashMap容量的初始化实现是非常重要的，特别是在大规模数据处理时。HashMap的容量初始化可以极大地影响程序的性能。在本文中，我们将详细介绍Java中HashMap容量的初始化实现...
HashMap之resize()方法源码解读.docx
06-17
HashMap的resize()方法是HashMap中最核心的方法之一，该方法负责扩容HashMap的容量，以便存储更多的键值对。下面我们将对HashMap的resize()方法进行源码解读，了解其扩容机制和原理。 一、resize()方法概述 resize...
HashMap扩容机制
最新发布
m0_64363449的博客
08-05 1610
3.5 扩容时，是创建一个新的数组，然后重新计算每个元素的hash值，找到元素在新数组中的对应位置，然后将链表以头插入的方式一一插入（每次扩容链表都会倒置）4.1 JDK8扩容有分两种情况，一种是元素个数超过阈值需要扩容，一种是当链表上的元素大于8，数组个数还没到达64，无法转化为红黑树，也会进行扩容。3.3 第一次put时候，会初始化数组，判断当前容量是否为2的幂数，不是则将容量变为2的幂数，并根据负载因子确定阈值（第一次扩容，初始化数组）。16=32，即容量变为原来的2倍，阈值=新容量。
HashMap的扩容机制
〆、风神的博客
11-15 2759
为了方便说明，这里明确几个名词： capacity 即容量，默认16。 loadFactor 加载因子，默认是0.75 threshold 阈值。阈值=容量*加载因子。默认12。当元素数量超过阈值时便会触发扩容。 什么时候触发扩容？ 一般情况下，当元素数量超过阈值时便会触发扩容。每次扩容的容量都是之前容量的2倍。 HashMap的容量是有上限的，必须小于1<<30，即1073741824。如果容量超出了这个数，则不再增长，且阈值会被设置为Integer.MAX_VALUE（ ，即永远不会超
三顾HashMap，一顾结构，二顾变量，三顾构造函数及首次扩容原理
qq_43227967的博客
06-04 491
背景摘要：在Map集合中，最常用的集合就是HashMap集合了。相信各位也能脱口而出她的特征，JDK7（以下简称为7）和JDK8（以下简称为8）源码和实现不一样。7底层由数组+单向链表实现。在这之前我们提到过基于数组和链表实现的两个集合。ArrayList与LinkedList。那么在8源码中新增了红黑树这么一个数据结构，由于其特性大大增加了查询效率。同时HashMap也是无序且线程非安全。那么今天基于7的源码来三顾HashMap。一顾结构解析、二顾核心变量、三顾构造函数及首次扩容原理。 HashMap
HashMap的初始容量机制及扩容机制
热门推荐
Apeopl的博客
03-30 1万+
通常在我们的应用中，HashMap是用到最多的数据结构之一，在JDK1.8之前，它的底层结构是数组+链表，而在JDK1.8之后，为了查询效率的优化（主要是当哈希碰撞较多的时候），它的底层结构变成了数组+链表+红黑树。今天就来探讨一下HashMap的扩容机制，这也是面试时被问到最多的问题。首先看一下源码中HashMap的四种构造方法。 从源码中可以看出：HashMap提供四种构...
深入理解HashMap的扩容机制
HD243608836的博客
10-29 449
一、什么时候扩容： 网上总结的会有很多，但大多都总结的不够完整或者不够准确。大多数可能值说了满足我下面条件一的情况。 扩容必须满足两个条件： 1、 存放新值的时候当前已有元素的个数必须大于等于阈值 2、 存放新值的时候当前存放数据发生hash碰撞（当前key计算的hash值换算出来的数组下标位置已经存在值） 二、下面我们看源码，如下： 首先是put()方法 public...
mybatis 之 resultType="HashMap" parameterType="list"
weixin_30244889的博客
08-03 130
public ServiceMessage<List<Map<String, Object>>> queryGoodsStockInfo(List<Long> goodsIds) { try { if (goodsIds == null || goodsIds.size() < 1) { ...
Map的使用需注意
Dustmicro的博客
08-04 1144
Map Map在Java中是一个接口，常见的实现类有： HashMap,LinkedHashMap,TreeMap和ConcurrentHashMap *每个类对应的结构* 1、HashMap new一个HashMap时会发生什么？ HashMap有几个构造方法但最主要的就是指定初始值以及负载因子的大小，如果我们不指定，默认HashMap的大小为16，负载因子的大小为0.75. HashMap的大小只能是2次幂 假设传一个10进去，实际上最终HashMap的大小是16，传一个7进去。。。。。是8。
hashmap初始容量及扩容机制
05-18
负载因子是指当 HashMap 中的元素个数达到容量与负载因子的积时就会触发扩容操作，将容量扩大为原来的两倍。 在进行扩容操作时，HashMap 会新建一个容量为原来两倍的数组，将原数组中的元素重新计算 hash 值，然后...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值