源码解析：HashMap：哈希表（JDK8）

最新推荐文章于 2022-05-27 13:38:33 发布

colodoo（纸伞）

最新推荐文章于 2022-05-27 13:38:33 发布

阅读量354

点赞数 1

分类专栏： Java源码解析文章标签： java 数据结构 hashmap 算法链表

本文链接：https://blog.csdn.net/lodog1/article/details/105547094

版权

Java源码解析专栏收录该内容

2 篇文章 0 订阅

订阅专栏

之前写过一篇关于HashMap的文章，只是粗略的介绍了一下HashMap的整体架构，但是没有很彻底阅读整个源码（暂不阅读红黑树部分源码）。
如果你想简单的了解HashMap的总体结构，可以阅读这篇文章。
【Java面试】彻底搞懂HashMap

源码解析：HashMap：哈希表（JDK8）

这次直接通过阅读源码的方式来理解HashMap更为直观，话不多说直接从put方法开始。

put

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

这里的hash方法我们也阅读看看它的算法是如何的。

static final int hash(Object key) {
    int h;
    // key为空则返回0
    // 否则取key的hash值赋值给h
    // h无符号右移16位
    // h 和 h无符号右移16位 之后的值异或运算
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

这次我们深入的了解一下它这么做的好处是什么这里先打个问号，从计算后面的下标的大小再来反推看看。

数组下标计算

n初始化为tab长度为16

i = (n - 1) & hash
i = 15 & hash

i = 00001111(二进制) & hash

位运算

n为15二进制为00001111，因为经过位运算只能后4位做位运算，多余的部分0&任何值都为0，所以i下标值只能在0到15这个区间。
这样计算的目的是为了计算出的下标永远只能落在这个范围内，否则根数组的下标则会越界。

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;
    // 首次插入数组为空，或者数组长度为0
    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相同则替换原有数据
        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);
                    // 如果哈希表长度大于等于8，则转换为树操作
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                // key相同情况，覆盖原值
                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;
        }
    }
    ++modCount;
    // 元素大于阈值，进行扩容操作
    if (++size > threshold)
        resize();
    afterNodeInsertion(evict);
    return null;
}

分析完数组部分，我们先看前面几个步骤，因为是第一个节点，所以我们就要对数组进行扩容，并且数组中也存在首个节点，所以就要研究resize方法是怎么实现数组的扩容的，和newNode是怎么形成单链表的。

当我们第一次插入的时候，假设算出来的下标为3，那么它就在下标为3的数组上加一个头节点，接下来阅读这几个方面详细的了解一下过程。

resize（扩容机制）

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    // 数组的长度赋值给oldCap
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 旧的容器临界值
    int oldThr = threshold;
    int newCap, newThr = 0;
    // 旧的数组长度大于0
    if (oldCap > 0) {
        // 超过范围则返回旧的数组
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 新的长度等于旧的长度乘以2
        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);
    }
    // 阈值等于0
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    // 新的阈值
    threshold = newThr;
    // 新的阈值初始化新的对象数组
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    // 如果旧的数组不为空
    if (oldTab != null) {
        // 遍历数组
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            // 不为空
            if ((e = oldTab[j]) != null) {
                // 置空
                oldTab[j] = null;
                // 下一个链表节点是空
                if (e.next == null)
                    // 该节点赋值给数组
                    newTab[e.hash & (newCap - 1)] = e;
                // 下一个节点是一个树节点
                // 则进行树操作
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        // 下一个节点赋值给next
                        next = e.next;
                        // hash值和旧的数组长度异或结果为0
                        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;
}

newNode

这个方法用于新增新的链表节点，我们来看看它的内部结构是怎么样的。

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

单链表的组成也是很简单的，就是上一个节点，保存下一个节点的对象，通过遍历next来循环整个链表结构，而链表的头放在数组上。

第一个节点

常量

读到这里一些常量可能的定义我们还没有详细的解读，这个可能会影响我们的理解，我们继续读常量部分。

/**
 * 初始化时容器的大小，必须是2的幂，默认是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;

/**
 * 树的阈值，当单链表达到阈值则开始进行树结构，JDK8开始
 */
static final int TREEIFY_THRESHOLD = 8;

/**
 * 在哈希表扩容时，如果发现链表长度小于 6，则会由树重新退化为链表。
 */
static final int UNTREEIFY_THRESHOLD = 6;

/**
 * 在转变成树之前，还会有一次判断，只有键值对数量大于 64 才会发生转换。
 */
static final int MIN_TREEIFY_CAPACITY = 64;

哈希碰撞

hash碰撞是指当我们之前分析的下标计算中，因为我们下标的范围是有限的，当我们出现两次相同的下标的时候，就是说这个节点在数组中的位置是相同的，也就出现了哈希碰撞。

JDK8引入了红黑树的设计，因为还没完全理解红黑树部分的代码，暂时没有分析和阅读。

总结

HashMap总体设计是根据哈希表结构设计的。
HashMap哈希表的下标由key的值和哈希算法决定，经过计算后落在0-15范围内。
HapMap中超过一定阈值后，会对容器进行扩容操作。

参考资料

你真的懂大厂面试题：HashMap吗？
hashMap resize原理 jdk1.8
HashMap的扩容机制—resize()
深入理解哈希表
 JDK8：HashMap源码解析：treeifyBin方法

文章中出现的任何错误欢迎指正！共同进步！

最后做个小小广告，有对WEB开发和网络安全感兴趣的，可以加群一起学习和交流！

交流群
QQ：425343603

colodoo（纸伞）

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
源码解析：HashMap：哈希表（JDK8）

之前写过一篇关于HashMap的文章，只是粗略的介绍了一下HashMap的整体架构，但是没有很彻底阅读整个源码。【Java面试】彻底搞懂HashMap这次直接通过阅读源码的方式来理解HashMap更为直观，话不多说直接从put方法开始。putpublic V put(K key, V value) { return putVal(hash(key), key, value, fal...
复制链接

扫一扫