《HashMap的数据结构》

吃土不秃.

已于 2023-09-14 14:30:55 修改

阅读量192

点赞数 4

文章标签：数据结构 java 开发语言

于 2023-05-30 11:35:09 首次发布

本文链接：https://blog.csdn.net/weixin_62226624/article/details/130936520

版权

1.HashMap的内部结构

2.有参构造方法

3.HashMap的相关参数

（1）DEFAULT_INITIAL_CAPACITY

（2）MAXIMUM_CAPACITY

（3）DEFAULT_LOAD_FACTOR

讲阈值之前：

（4）TREEIFY_THRESHOLD

（5）UNTREEIFY_THRESHOLD

4.HashMap的扩容

查阅HashMap相关API及资料，得到以下关于HashMap数据结构的了解总结。

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

首先，HashMap继承了抽象类AbstractMap实现了Map接口、可克隆接口、可序列化接口（标记接口）。

看下面这张图片：

1.HashMap的内部结构

HashMap的内部结构是基于数组+链表+红黑树积进行存储的。

数组类型为Node[ ],

每个节点中中保存了结点的hash值、k值、v值以及与下一个结点建立联系的next值（这使得每一个Node对象都是单向链表的组成结点）。

当新添加一个KV键值对元素时，通过该元素的key获取当前元素hash值，计算该元素在数组中应该保存的下标位置。

如果该下标位置如果已经存在其它Node对象，则采用链地址法处理，即将新添加的KV键值对元素将以链表形式存储。将新元素封装成一个新的Node对象，插入到该下标位置的链表尾部（尾插法）。

当链表的长度超过8并且数组长度大于64时，为了避免查找搜索性能下降，该链表会转换成一个红黑树。


static final int TREEIFY_THRESHOLD = 8;//链表长度

static final int MIN_TREEIFY_CAPACITY = 64;//数组长度

2.有参构造方法

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)//初始容量小于0，抛出不合法初始容量异常信息
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)//初始容量大于最大容量
            initialCapacity = MAXIMUM_CAPACITY;//最大容量赋给初始容量
        if (loadFactor <= 0 || Float.isNaN(loadFactor))//加载因子<=0或加载因子为空
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);//抛出不合法加载因子异常信息
        this.loadFactor = loadFactor;//以上均无，将加载因子赋给当前对象的加载因子
        this.threshold = tableSizeFor(initialCapacity);//创建初始容量大小的链表
    }

3.HashMap的相关参数

（1）DEFAULT_INITIAL_CAPACITY

第一次添加元素时，若数组为空，默认创建初始容量为16的数组。（每次将数组容量按照默认初始化容量16进行扩容）

//初始容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

（2）MAXIMUM_CAPACITY，定义哈希表的最小树形化容量

当哈希表中容量大于该值才会树形化（转化为红黑树）

//哈希表的最小树形化容量
static final int MAXIMUM_CAPACITY = 1 << 30;

（3）DEFAULT_LOAD_FACTOR，定义默认负载（加载）因子为0.75(浮点型)。

//加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

讲阈值之前：

首先明确一点，HashMap中，阈值=容量*负载因子

举个例子：若当前HashMap中容量为16，负载因子默认为0.75，那么当size（元素个数）达到16*0.75=12时就会触发扩容。

（4）TREEIFY_THRESHOLD，定义树形化阈值为8

当桶中元素个数超过该值是，将链表树形化，需使用红黑树节点替换链表节点。

//扩容阈值
static final int TREEIFY_THRESHOLD = 8;

（5）UNTREEIFY_THRESHOLD，定义还原阈值为6

扩容时，元素个数小于该值即将树形的桶元素还原为链表结构

static final int UNTREEIFY_THRESHOLD = 6;

4.HashMap的扩容

4.1 先介绍两个概念：

（1）数组容量（initialCapacity）：基础数组Node<K,V>[] table的长度。如果没有指定容量，添加第一个元素时，该数组按照默认值16进行初始化。

（2）加载因子（loadFactor）：用来表示HashMap集合中元素的填满程度，默认为0.75f。

越大则表示允许填满的元素就越多，集合的空间利用率就越高，但是冲突的机会增加。

越小则冲突的机会就会越少，但是空间很多就浪费。

HashMap的扩容方法为 resize（）：（源代码阅读）

这里提到的阈值可以理解为临界点（上限）。

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;//将第一次添加元素时的容量赋给节点数组oldTab值

        //若oldTab为空，oldCap=0否则为oldTab的长度
        int oldCap = (oldTab == null) ? 0 : oldTab.length;

        int oldThr = threshold;//扩容阈值threshold赋给oldThr
        int newCap, newThr = 0;//定义新容量，新阈值并初始化为0

        if (oldCap > 0) {//如果旧容量>0
            //再判断旧容量是否大于等于最大容量
            if (oldCap >= MAXIMUM_CAPACITY) {//是
                threshold = Integer.MAX_VALUE;//将整型的最大值赋给扩容阈值
                return oldTab;//返回旧的表长度
            }
            //否则让新容量等于旧容量的两倍，若新容量小于最大容量 并且旧容量大于等于默认初始容量
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold//则新阈值为旧阈值的两倍
        }
        //若旧阈值大于0
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;//将旧阈值赋给新容量

        //以上两种情况均不满足
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;//令新容量为默认初始容量
            //新阈值为默认加载因子*默认初始容量
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {//若新阈值为0
            float ft = (float)newCap * loadFactor;//令ft等于新容量*加载因子

            /*新阈值等于三元运算符判断后的值
                1.若新容量小于最大容量且ft<最大容量，则新阈值即为ft
                2.否则新阈值为整型的最大值*/
                
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }

        //将新阈值赋给扩容阈值
        threshold = newThr;

        //屏蔽rawtypes、unchecked等警告信息
        @SuppressWarnings({"rawtypes","unchecked"})

            //创建一个容量为newCap的新Node[]数组newTab
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];

        table = newTab;//newTab赋值给table

        if (oldTab != null) {//若oldtab不为空
            for (int j = 0; j < oldCap; ++j) {//遍历该表
                Node<K,V> e;//结点e

                if ((e = oldTab[j]) != null) {//当前j下标元素赋给结点e,若e不为空
                    oldTab[j] = null;//让表中当前j下标对应元素为空
                    if (e.next == null)//若结点e的next值为空
                        //将结点e赋在新节点数组的e的hash值对应的位置且newCap减1
                        newTab[e.hash & (newCap - 1)] = e;
                    else if (e instanceof TreeNode)//不为空，若e的类型为TreeNode类型
                        //调用红黑树的split将红黑树从旧数组转移到新数组
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //e不为空且不是TreeNode类型
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;//初始化低位树的头结点、尾结点
                        Node<K,V> hiHead = null, hiTail = null;//初始化高位树的头结点、尾结点
                        Node<K,V> next;//next结点
                        //进入do...while循环
                        //next结点赋给e,当e不为空的情况下继续循环
                        do {
                            next = e.next;//next等于e的next
                            if ((e.hash & oldCap) == 0) {//若e的哈希值和就容量均为0
                                if (loTail == null)//判断低位树尾结点是否为空
                                    loHead = e;//是，e赋给当前低位树的头结点
                                else//否
                                    loTail.next = e;//e赋给当前低位树尾结点的next值
                                //其他情况，将e赋给低位树的尾结点
                                loTail = e;
                            }
                            else {若e的哈希值和就容量均为0不成立
                                if (hiTail == null)//判断高位树的尾结点是否为空
                                    hiHead = e;//是，e赋给当前高位树的头结点
                                else//否
                                    hiTail.next = e;//e赋给当前高位树的尾结点的next值
                                hiTail = e;//将e赋给高位树的尾结点
                            }
                        } while ((e = next) != null);
                        //若低位树的尾结点不为空
                        if (loTail != null) {
                            loTail.next = null;//低位树的尾结点的next值置为空
                            newTab[j] = loHead;//低位树的头结点放到新数组下标为j的位置
                        }
                        //若高位树的尾结点不为空
                        if (hiTail != null) {
                            hiTail.next = null;//高位树的尾结点的next值置为空
                            newTab[j + oldCap] = hiHead;//高位树的头结点放到新数组下标为j再加上旧数组长度的位置
                        }
                    }
                }
            }
        }
        return newTab;//返回新数组
    }

4.2 触发HashMap扩容的情况有两种：

1.当前HashMap中元素的个数达到 数组容量 × 加载因子的值时会扩容，扩容机制是增加为原来的两倍。比如，数组长度为16，加载因子默认0.75，当数组中元素达到16×0.75即12时，会触发扩容机制，数组长度扩容为原来的2倍即32。

2.HashMap底层是采用数组+链表+红黑树实现的，当链表长度达到阈值8并且数组长度超过64时，会触发扩容机制，此时链表会转为红黑树，减少搜索时间。

具体解释：

因为HashMap底层具体计算元素存储下标时，是根据当前的key进行Hash后获取哈希值，再将哈希值与数组长度-1做“&”运算求出当前这个元素在数组中的下标，难免会存在哈希冲突。如果当前元素计算出来的下标位置已经存在元素，会先判断两者内容是否相等，相等替换与不替换区别不大；不相等则在该位置上的元素就会以链表的形式存放，当前元素的next指向新添加的元素，形成链表。

此时就会有第二种情况的扩容。

以上鄙人拙见，后续还会加以完善，有什么不对望诸君指正！

吃土不秃.

关注

4
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
《HashMap的数据结构》

当哈希表中容量大于该值才会树形化（转化为红黑树）//哈希表的最小树形化容量//加载因子讲阈值之前：首先明确一点，HashMap中，阈值=容量*负载因子举个例子：若当前HashMap中容量为16，负载因子默认为0.75，那么当size（元素个数）达到16*0.75=12时就会触发扩容。当桶中元素个数超过该值是，将链表树形化，需使用红黑树节点替换链表节点。//扩容阈值扩容时，元素个数小于该值即将树形的桶元素还原为链表结构。
复制链接

扫一扫