集合源码解析：HashMap的底层实现原理(jdk8.0)

最新推荐文章于 2024-02-20 17:48:11 发布

百知_zmj

最新推荐文章于 2024-02-20 17:48:11 发布

阅读量543

点赞数 3

分类专栏：大厂面试题 JavaSE

本文链接：https://blog.csdn.net/java_lover_zpark/article/details/105459304

版权

JavaSE 同时被 2 个专栏收录

33 篇文章 3 订阅

订阅专栏

大厂面试题

11 篇文章 0 订阅

订阅专栏

源码解析JDK8.0集合：HashMap底层实现原理

一、HashMap的概述

HashMap是Map接口的实现类，键值对存储(基于哈希表的映射：根据指定的键，可以获取对应

的值)，并允许null作为键和值，线程不安全，即方法为非同步方法。这一点jdk7.0 和 jdk8.0没

有区别。

二、HashMap的存储结构

jdk7.0中的HashMap采用数组+链表形式进行存储，但是如果一个数组对应的链表长度过大

时，通过key进行查询时效率较低；为了提高效率，jdk8.0中HashMap最大的优化亮点就在

于采用了数组 + 链表 + 红黑树的存储方式。
jdk8.0的HashMap 底层结构依然是一个数组(默认长度为16)也称为哈希表，同样的数组元素

是一个单向的链表，每一个数组存储的元素代表的是每一个链表的头结点；但是当数组中某

并且一个链表长度>=8，数组的长度不小于 64 时，会将此链表转换为红黑树的存储方式，

存储结构如下：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fyEGNT4Z-1586609662644)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1572421716008.png)]$

三、HashMap内部实现原理机制(源码解析)

HashMap的基本元素

public class HashMap<K,V> extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable {
	/*
    	默认的初始容量为：16
    	1 << 4 代表将1左移4位：2^4 = 16
    */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
    
	//最大容量为2^30 = 1024*1024*1024 = 1073741824
    static final int MAXIMUM_CAPACITY = 1 << 30;

	/* 默认的负载因子
    	负载因子表示一个散列空间的使用程度。
    	当向集合容器中添加元素的时候，会判断当前容器的个数：
    	如果当前容器的个数 > 阈(yu)值：即底层数组长度*负载因子
    */
    static final float DEFAULT_LOAD_FACTOR = 0.75f;
    
	/*新增：
		如果数组某一个元素中的链表节点数 >= 8时，
		需要转换为 红黑树形式存储
	*/
    static final int TREEIFY_THRESHOLD = 8;

	/*新增：
		如果数值中某一个 元素转换为红黑树存储之后，在之后的操作中
		检测到节点数 <6 时，则解散红黑树存储，再 转换为 链表形式
		进行存储
	*/
    static final int UNTREEIFY_THRESHOLD = 6;
	
	/*新增：
		如果数组某一个元素中的链表节点数 >= 8时，需要转换为
		红黑树形式存储，但是 同时 需要 还满足此时的数组长度
		不能不小 64 ，否则也不会转换为 红黑树形式存储
	*/
	static final int MIN_TREEIFY_CAPACITY = 64;
	
	/*改变：
		jdk8.0中底层数组类型由 Entry 类型改变为 Node 类型
		但是 Node 为 Map.Entry接口的实现类
		(注意：Entry为Map接口中的内部接口)
	*/
	transient Node<K,V>[] table;

	// Map集合中键值对的 个数
	transient int size;
	
	// 记录对集合中元素修改的次数
    transient int modCount;

    /* 扩容的临界值(阈值)，或者所能容纳的key-value对的极限。
       当size>threshold的时候就会扩容
    */
    int threshold;

	// 加载因子
    final float loadFactor;

jdk8.0中HashMap的实现类中字段部分相对于 jdk7.0做出了部分的改变，没有改变的字段不再详细介绍，以下介绍的为改变或是新增的字段：

(1) TREEIFY_THRESHOLD = 8 和 MIN_TREEIFY_CAPACITY = 64

数组中某一个元素对应的链表形式存储是否需要转换为红黑树进行存储的依据。

如果链表长度大于等于 8，同时Node[] table数组长度不小于 64，则将此链表转换为

红黑树进行存储。

(2) UNTREEIFY_THRESHOLD = 6

被转换为红黑树进行存储的再次转换为链表存储的临界值

(3) Node<K,V>[] table

Node<K,V>[] table 相当于 jdk7.0 中的Entry[] table，就是HashMap的底层的数组，

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

存储的具体结构如下：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ehlWRsIZ-1586609662645)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1572492518766.png)]$

HashMap中的构造方法相比于 jdk7.0中的HashMap 没有大的变动，不再具体讲解

HashMap中存储：put方法的实现

public V put(K key, V value) {
    // 调用 hash方法获取 key对应的哈希码值
    return putVal(hash(key), key, value, false, true);
}

putVal 方法的实现源码如下：

// 将存储单独定义为一个 putVal方法，为了代码的复用性
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 为空，则新建一个 table
    if ((tab = table) == null || (n = tab.length) == 0)
        // 调用 resize 方法实现新建table数据
        n = (tab = resize()).length;
    /*
    	根据 数组长度 和 哈希码值进行 与 运算得到一个存储下标
    	如果存储位置上，没有元素，则新建 一个 Node 直接存储即可
    */
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    // 如果对应下标位置上，已经有元素
    else {
        Node<K,V> e; K k;
        // 如果恰巧和第一个节点中的数据冲突，将 e 指向第一个节点
        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 {
            // 利用循环，遍历链表中的每一个节点，判断 是否存在重复的键
            for (int binCount = 0; ; ++binCount) {
                
                // 如果到了链表的尾部，还没有发现有相同的key
                if ((e = p.next) == null) {
                    // 则新建一个新节点插入到链表的尾部
                    p.next = newNode(hash, key, value, null);
                    //如果链表长度大于TREEIFY_THRESHOLD对应的数值
                    if (binCount >= TREEIFY_THRESHOLD - 1) 
                        // 转换为 红黑树 进行存储
                        treeifyBin(tab, hash);
                    break;
                }
                // 如果发现和某个节点的 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;
        }
    }
    ++modCount; // 对集合修改的次数加1
    // 判断是否需要扩容
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

解析：put方法实现的原理如下：

(1) 调用 hash方法获取 key 对应的哈希码值

(2) 如果 table 为空，则先新建一个table数组

(3) 如果根据key的哈希码值和table数组长度获取的存储下标位置上没有任何

数据，则直接存储即可

(4) 如果需要存储的table对应下标位置上已有元素，则需要判断是否有冲突key：

a. 先判断数组对应位置上，第一个节点是否存在冲突，冲突直接获取此节点

b. 再判断是否采用的红黑树存储，是-则利用红黑树中的方法存储键值对

c. 采用链式存储，则需要遍历的判断链表中是否有冲突的 key

I. 如果到最后一个节点，还没有发现有冲突的key，则新建一个节点插入到尾部

同时在这个步骤中判断链表是否需要转换为红黑树进行存储，依据为链表长度

是否大于等于8

II. 如果循环过程中，发现有冲突的key，则获取该节点，同时结束循环

d. 如果存在有冲突的 key，则新值替换旧值

应用层解析总结：jdk7.0 和 jdk8.0 要求没有区别

如果自定类型的元素作为HashMap的键时，需要覆盖hashCode方法和equals方法：

(1) 覆盖hashCode方法的原则：

a. 必须保证内容相同的元素返回相同的哈希码值

b. 为了提高效率，尽可能做到内容不同的元素返回不同的哈希码值

(2) equals方法：内容相同的对象返回true。

HashMap的读取：get方法的实现

public V get(Object key) {
    Node<K,V> e;
    // 调用getNode方法获取和 key相同的 Node 节点
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

getNode方法的源码：

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    // 如果table不为空，同时table长度大于0，同时数组对应下标存储内容不为null
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        // 如果 数组对应下标的第一个节点中的key 和 要查找的key相同
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && 
                                        key.equals(k))))
            // 直接返回第一个节点
            return first;
        // 如果第一个节点的key和要查找的key不同，同时后面还有其他节点
        if ((e = first.next) != null) {
            // 如果采用的是红黑树方式进行存储的
            if (first instanceof TreeNode)
                // 通过 红黑树 获取 key 对应的Node
                return ((TreeNode<K,V>)first).getTreeNode(hash, 
                                                          key);
            // 不是红黑树，则需要遍历节点，查找和 key相同的节点
            do {
                // 如果查找到和key相同的节点，返回该节点
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && 
                                            key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    // 如果 table为null，或是不存在该key，则返回null即可
    return null;
}

解析：put方法实现原理如下：

(1) 如果 table不为空，或是对应key对应的存储下标元素不为null

a. 先判断第一个节点是否和要查找的key映射的节点，相同则直接返回此节点

b. 如果第一个节点不是要查找的key映射的节点，则需要判断后面的节点

I. 如果为红黑树形式存储，则需要利用红黑树进行操作

II. 如果为传统链表形式存储，则遍历所有节点，找到则返回对应的Node

(2) 如果table为空，或是key没有映射的结果，则返回null

HashMap的扩容：resize方法

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长度是否大于 0
    if (oldCap > 0) {
        // 如果 table长度大于最大空间，无法再扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 则扩容的临界值设置为Integer区间的最大值
            threshold = Integer.MAX_VALUE;
            // 将原有数组返回
            return oldTab;
        }
        // 如果没超过最大空间，则扩大原有的两倍
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) 
        newCap = oldThr;
    else {               
        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;
    // 基于新的容量创建新 Node数组 ---》新的哈希表
    @SuppressWarnings({"rawtypes","unchecked"})
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 遍历原有table 数组，重新计算每一个元素的新位置
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            //如果数组对应的下标元素 不为 null
            if ((e = oldTab[j]) != null) {
                oldTab[j] = null;
                // 如果数组此下标对应位置仅有一个Node节点
                if (e.next == null)
                    // 存储在新数组 位置上即可
                    newTab[e.hash & (newCap - 1)] = e;
                // 如果此位置采用的红黑树形式存储，则将红黑树进行分离
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, 
                                             j, oldCap);
                // 如果此位置采用的链式存储了多个Node节点元素
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 循环的获取每一个Node节点的新位置
                    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;
}

解析：resize方法为HashMap的扩容方法，如果Map中存储的键值对的

个数 > 扩容的临界值(threshold)时，Node[] table 数组就需要扩容。

四、总结

jdk7.0中的HashMap是采用拉链的方法解决存储冲突的问题，如果一个桶(数组元素)中冲突

严重，即链表过长，会导致效率降低，而jdk8.0通过红黑树的形式进行优化，将效率适当的

提高。但是相比链式结构，树型结构的节点比较占空间，所以这是一种以空间换时间的改进

方式。

备注：关于红黑树的相关内容，可以查阅数据结构相关资料，翻看树的章节。

百知_zmj

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
集合源码解析：HashMap的底层实现原理(jdk8.0)

源码解析JDK8.0集合：HashMap底层实现原理一、HashMap的概述HashMap是Map接口的实现类，键值对存储(基于哈希表的映射：根据指定的键，可以获取对应的值)，并允许null作为键和值，线程不安全，即方法为非同步方法。这一点jdk7.0 和 jdk8.0没有区别。二、HashMap的存储结构jdk7.0中的HashMap采用数组+链表形式进行存储，但是如果一个数组...
复制链接

扫一扫