Java HashMap源码学习

最新推荐文章于 2024-10-09 11:13:12 发布

weixin_43102756

最新推荐文章于 2024-10-09 11:13:12 发布

阅读量182

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_43102756/article/details/122464740

版权

Java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、继承体系

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

二、域

初始容量：默认是16

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;

最大容量

static final int MAXIMUM_CAPACITY = 1 << 30;

负载因子：默认是0.75

static final float DEFAULT_LOAD_FACTOR = 0.75f;

说明：
1、若负载因子太小，虽然减少了哈希冲突，其链表长度或红黑树高度较小，因此可以增加查询效率，但是会导致空间浪费，以及在往map中放元素的过程中会导致较高频率的扩容操作
2、若负载因子过大，虽然提高了空间的利用率，但是会增加哈希冲突，导致底层的链表长度增加进而转换成红黑树，且红黑树的高度也会较高，导致查询效率降低，以及在往map中放元素的过程中会导致树化操作增多
3、综合时间和空间的考虑，将负载因子设计成一个0.5到1之间的数，至于为什么是0.75，涉及到概率问题
hashmap在插入元素时服从二项式分布：即插入数据是否发生哈希冲突
前提：实验的hash值是随机的，将他们经过hash运算映射到hash表上也是随机的，彼此相互独立
HashMap设计目的：尽可能降低hash冲突，即在n次put操作中，hash冲突尽可能少，而碰撞为0的概率是
$C^0_n \times (\frac{1}{s})^0 \times (1 - \frac{1}{s})^n = (1 - \frac{1}{s})^n$
式中：s为哈希表的容量
一般我们要求碰撞为0概率要尽可能大，需要大于0.5，经过推导可以得到下式：
$\frac{n}{s} \leq \frac{ln2}{sln(\frac{s}{s - 1})}$
可得到负载因子：
$\displaystyle \lim_{s \to \infty}\frac{ln2}{sln(\frac{s}{s - 1})}$
其中：
$\displaystyle \lim_{s \to \infty}sln(\frac{s}{s - 1}) = 1$
因此 $\approx 0.693$
而为了加快哈希计算以及减少哈希冲突，在Java中HashMap的长度被设计成2的整数次幂，因此需要在0.693附近选择一个数字作为负载因子来保证阈值 $\times 2^n$ 最好是个整数，而0.75正好满足。
注意：虽然上述推导具有一定数学意义，但是负载因子的选择应该是有设计者自身的考虑，在C#中类似于Java的HashMap的类叫HashTable，其负载因子选择了0.72

树化阈值、反树化阈值、最小树化容量

static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
/*
说明：
1、上面三个值与树化有关，配合使用
2、当由于哈希冲突导致链表长度达到8时，就会将链表转换成树的结构
3、当树中的节点数量减少到6时就将树结构转换成链表结构，设计成6目的在于避免节点数量的波动导致的树化和链化的交替出现
2、MIN_TREEIFY_CAPACITY为最小树化容量，默认值是64
   在容量小于64时，且哈希冲突导致链表长度达到8，会采取扩容的方式，而不会进行树化操作
*/

元素节点内部类

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; }
        public final String toString() { return key + "=" + value; }
        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }
        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }
        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

元素表 transient 不可序列化，长度为 $2^n$

transient Node<K,V>[] table;

修改次数

transient int modCount;

解释

三、工具方法

hash函数

static final int hash(Object key) {
	int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

hash函数不能保证得到唯一的结果，即不同的输入可能得到相同的结果，进而导致发生哈希冲突；上面这个方法将hashCode的高位和低位混合参与计算，带入了高位的影响，可以降低发生哈希冲突的概率。

tableSizeFor函数

static final int tableSizeFor(int cap) {
    int n = cap - 1;
    n |= n >>> 1;
    n |= n >>> 2；
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

这个函数会将输入值转化成一个 $2^n$ 的整数，可用于保证容量为2的整数次幂。

四、重点方法

putMapEntries

//evict – false when initially constructing this map, else true (relayed to method afterNodeInsertion).
/**
* evict:
* false: 表示处于初始化hashmap阶段
* true：与afterNodeInsertion有关，见putVal方法
*/
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    int s = m.size();
    if (s > 0) {
        if (table == null) { // pre-size
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY);
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        else if (s > threshold)
            resize();
        for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            K key = e.getKey();
            V value = e.getValue();
            putVal(hash(key), key, value, false, evict);
        }
    }
}

在这个方法中，会先判断hashmap中的table是否初始化且分配了长度，如果没有，会计算放入参数中的map需要的容量，通过调用tableSizeFor函数保证容量为2的整数次幂，因为此时table为null，阈值threshold就是容量，这一点在hashmap的构造函数中也是这么处理的。因为hashmap中存储节点的table数组采用延时初始化，在插入键值对时才初始化这个数组，即在第一次调用putVal方法时初始化
如果table不为null，则table已经初始化，此时需要判断插入的map的元素数量是否大于阈值，是就扩容，再依次插入元素

get和getNode

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
            ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}

get方法会调用getNode方法来获取元素，其中getNode方法：
3. first = tab[(n - 1) & hash]，找到key的hash映射到table中的下标，这里有个前提条件是容量为 $2^k$ ，该条件由tableSizeFor方法保证。
原因：首先，只有在容量为2的整数次幂时，将元素散列到table中求下标时(n - 1) & hash才等效为一般的取模运算hash % capacity；其次，为什么要采取(n - 1) & hash运算，因为这种运算相较于取模运算较快；这也阐述了容量设计为2的整数次幂的其中一个原因，即为了散列到table中更快速
4. 通过参数hash散列到表对应的下标，若该下标处不为null且key相等，则找到了需要的值；若key不相等，且该节点后续节点不为空，则判断是树节点还是链表节点，分别采用对应的方法来查找最后得出结果

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;
    if ((tab = table) == null || (n = tab.length) == 0)
        //若table为空，说明table还没初始化，此时通过resize初始化，延时加载机制
        n = (tab = resize()).length;
    //通过散列得到table在下标处有没有节点，没有就直接新建节点放到table该下标处
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    //通过散列得到table在下标处有节点，此时p就是这个节点
    else {
        Node<K,V> e; K k;
        //散列表table在这个下标出的节点就是插入的节点，此时只需要修改节点的值
        if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //p的key不等于插入节点的key，检查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
                    	//达到阈值后调用该方法，该方法会首先判断table数组长度即容量大于64，不是就扩容而不树化链表；反之就树化链表
                        treeifyBin(tab, hash);
                    break;
                }
                //找到了插入节点的位置，跳出循环
                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);
            //此时直接返回，原因在于map中存在key，插入需要的节点不会增加map中的数量，也不会修改现存的map结构，就不需要判断是否需要扩容
            return oldValue;
        }
    }
    //若key在map中原本不存在，则需要插入一个新节点，导致map结构改变，需要增加这个变量的值
    ++modCount;
    //插入了新节点，map的节点数量增加，同时判断此时节点数量是否超过阈值，超过了就需要扩容
    if (++size > threshold)
        resize();
    //空函数
    afterNodeInsertion(evict);
    //插入了新节点，不需要返回值
    return null;
}

执行步骤
在这里插入图片描述

引用自https://blog.csdn.net/visant/article/details/80045154 十分感谢原博主制作的图片！

resize方法返回一个Node数组

final Node<K,V>[] resize() {
    Node<K,V>[] oldTab = table;
    //判断是否是未初始化或table长度为0
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    int oldThr = threshold;
    int newCap, newThr = 0;
    //已经初始化且table长度大于0
    if (oldCap > 0) {
    	//如果原table长度大于等于最大的容量许可，此时已经无法扩容，只能提高阈值再返回原table
    	//此时table并没有改变
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        //如果原table容量扩充两倍后仍小于最大许可容量且
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    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) {
        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 = 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;
}