HashMap的源码分析--put和get的流程

文大奇Quiin

已于 2023-12-06 10:42:24 修改

阅读量469

点赞数 1

分类专栏： Java 文章标签：哈希算法散列表 java

于 2022-06-15 14:05:55 首次发布

本文链接：https://blog.csdn.net/wenqi1992/article/details/125292707

版权

Java 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

HashMap的介绍

HashMap位于java.util包下，基于哈希表的一个Map接口的实现。HashMap除了实现Map接口外，还继承了AbstractMap<K,V>，HashMap以键值对<key, value>的形式进行存储，并且允许null键和null值。HashMap是线程不安全的。

HashMap的数据结构

HashMap 底层实现为数组 + 链表（链表长度默认大于等于8且容量大于等于64转化成红黑树），数组是HashMap的主体，链表是为了解决哈希冲突而存在的。HashMap 通过调用 key 所属类的 hashCode 方法计算出 key 的 hash 值，然后将 hash 值通过哈希函数计算出更加复杂的 hash 值，再将算出的 hash 值和数组长度减1进行 & 运算，获得在数组中存放的位置。

HashMap源码分析

属性的介绍

// HashMap的默认初始化容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

// HashMap的最大容量1073741824
static final int MAXIMUM_CAPACITY = 1 << 30;

// HashMap的默认加载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 链表长度大于等于8转化成红黑树
static final int TREEIFY_THRESHOLD = 8;

// 红黑树节点小于等于6退化为链表
static final int UNTREEIFY_THRESHOLD = 6;

// HashMap容量大于等于64，是链表转红黑树的前提条件
static final int MIN_TREEIFY_CAPACITY = 64;

// HashMap的数组主体
transient HashMap.Node<K,V>[] table;

// 保存所有键-值的集合
transient Set<Map.Entry<K,V>> entrySet;

// HashMap中键值对的个数
transient int size;

// HashMap结构修改的次数
transient int modCount;

// 达到该值就进行扩容 capacity * load factor
int threshold;

// 加载因子
final float loadFactor;

put的过程

当我们调用put方法存储元素时，方法里面又调用了putVal方法，这时除了传key和value，还传入了一个hash值。

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

HashMap里面计算hash值的过程

static final int hash(Object key) {
    int h;
    // 如果key为null，则返回0
    // 不为null，则获取key的hashCode()为h，再对h进行右移16位得到h1，最终返回 h ^ h1
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

put的核心代码

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // 第一步：计算出该元素在数组中的位置(n - 1) & hash
        // 第二步：从数组中获取该位置的Node
        if ((p = tab[i = (n - 1) & hash]) == null)
            // 如果为null，则创建一个新Node放进数组，put成功
            tab[i] = newNode(hash, key, value, null);
        else {
            HashMap.Node<K,V> e; K k;
            // 如果该位置存在Node，比较key的hash值和equals
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 如果hash值和equals都相等，则表示是重复的key，把p赋值给e，在后面进行更新value
                e = p;
            // 如果是红黑树，以红黑树的方式检索，比较
            else if (p instanceof HashMap.TreeNode)
                e = ((HashMap.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);
                        // 判断是否超过链表的最大长度
                        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;
                }
            }
            // e不为null，说明key已经存在
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    // 用新的value更新老的value
                    e.value = value;
                afterNodeAccess(e);
                // 如果是key已经存在，则返回老的value
                return oldValue;
            }
        }
        ++modCount;
        // 判断是否需要扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        // 如果key值不存在，put成功返回null
        return null;
    }

get的过程

当我们调用get方法时候，get方法里面是通过getNode方法去获取Node，从而获取到Node的value

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(key)) == null ? null : e.value;
}

get的核心代码

final HashMap.Node<K,V> getNode(Object key) {
        HashMap.Node<K,V>[] tab; HashMap.Node<K,V> first, e; int n, hash; K k;
        // 第一步：计算出该元素在数组中的位置(n - 1) & hash
        // 第二步：从数组中获取该位置的Node
        if ((tab = table) != null && (n = tab.length) > 0 &&
                (first = tab[(n - 1) & (hash = hash(key))]) != null) {
            // 如果hash值和equals都相等，则返回该Node
            if (first.hash == hash && // always check first node
                    ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
                // 如果是黑红树，则检索红黑树获取Node
                if (first instanceof HashMap.TreeNode)
                    return ((HashMap.TreeNode<K,V>)first).getTreeNode(hash, key);
                // 如果是链表，则检索链表获取Node
                do {
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        // 如果没有找到对应的key，则返回null
        return null;
    }