• java集合 HashMap


    1.什么是哈希表?

    可以参考这篇文章说的很详细

    这篇文章里面详细描述了

    1. 什么是哈希表

    2. 什么是哈希冲突

    3. 如何减少和处理哈希冲突

    4. 哈希表的扩容和Refresh

    基础知识不多赘述

    2.HashMap

    2.0 前言

    1.HashMap的数据结构

    2.HashMap的相关参数(初始容量、加载因子)含义以及原因

    3.put和get方法操作具体是如何实现

    4.Hash的过程以及优缺点

    5.rehash造成的线程安全问题以及如何解决,具体见这篇文章

    6.扩容的过程

    2.1 数据结构

    整体设计
    散列函数:hashCode()+除留余数法
    冲突解决:链地址法

    java1.7 数据结构是 数组+链表
    java1.8 数据结构是 数据+链表+红黑树

    2.2 重要参数

    2.2.1 两个重要参数

    1.默认初始容量:16,必须是 2 的整数次方

    2.默认加载因子的大小:0.75,为什么是0.75上面哈希表文章详细说明

    2.2.2 初始容量和加载因子怎么理解

    首先根据哈希表,key通过f(key)方法映射到对应的数据下标。
    那么初始容量就是数组默认大小,比如10
    加载因子就是默认数组填充个数/数组总大小,比如默认大小是10,填充7个就是极限,填充第八个前就要扩容。

    若:加载因子越大,填满的元素越多,好处是空间利用率高了,但冲突的机会加大了,链表长度会越来越长、查找效率降低;
    反之,加载因子越小,填满的元素则越少,好处是冲突的机会减小了,但空间浪费多了,表中的数据将过于稀疏(很多空间还没用,就开始扩容了)。

    2.3 主要方法

    2.3.1 put方法解析

    java 1.7版本 put方法解析

    //put方法
    public V put(K key, V value) {
        //1.判空操作
        if (key == null)
            return putForNullKey(value);
        //2.拿到key对应的hash
        int hash = hash(key.hashCode());
        //3.拿到当前key在数组中对应的位置i
        int i = indexFor(hash, table.length);
        //4.从i开始遍历,这个其实是遍历链表了
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //4.1.判断该链表上是否有相同的key
            //如果有直接覆盖原值,并返回原值
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
    
        modCount++;
        //5.将key,value添加到i处
        addEntry(hash, key, value, i);
        return null;
    }
    
    void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }
    

    1.7版本的put操作可以总结为以下几步

    1.判空
    2.拿hash值
    3.拿数组下标
    4.遍历链表赋值

    流程就这些,至于细节问题,
    比如判断之后如何操作,怎么算的hash值,怎么算的数组下标,怎么添加新数据到数组怎么扩容先不关心。

    大致流程先记住,细节可以慢慢思考,过分关注细节,很难把握整体

    java 1.8版本 put方法解析

    public V put(K key, V value) {
        //1.计算hash值,调用内部putVal方法
        return putVal(hash(key), key, value, false, true);
    }
    
    /**
     * Implements Map.put and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //2.判空扩容操作
        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);//3.1 节点不存在,创建新节点并添加到数组
        else {//3.2 当前节点存在
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p; //3.2.1 直接命中当前节点
            else if (p instanceof TreeNode)
    	   //3.2.2 当前节点是红黑树,处理红黑树
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
    	    //3.2.3 当前节点是普通链表,遍历链表
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {//3.2.3.1 新节点追加到尾部
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);//3.2.3.2 链表长度大于8且数组长度大于64,转成红黑树
                        break;
                    }
    		//3.2.3.3 找到覆盖节点退出遍历
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
    	//3.2.4 有覆盖节点,执行交换操作,返回老节点
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);//这是一个空实现的函数,用作LinkedHashMap重写使用。
                return oldValue;
            }
        }
        ++modCount;
        //4 判断是否扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);//这是一个空实现的函数,用作LinkedHashMap重写使用。
        return null;
    }
    

    java 1.8版本的put操作可以总结为

    1.计算hash值
    2.判空,空数组扩容
    3.1 节点不存在创建新节点,需要就重新创建,并赋值给到数组
    3.2 节点存在
    3.2.1 命中节点直接替换
    3.2.2 命中红黑树节点,转到红黑树处理
    3.2.3 命中链表节点,转链表处理,其中包括追加到尾结点和链表转红黑树操作
    3.2.3.1 新节点追加尾部
    3.2.3.2 链表长度大于8且数组长度大于64,转红黑树
    3.2.3.3 找到覆盖节点,退出遍历
    3.2.4 有覆盖节点就执行交换操作,并返回老节点
    4 最后再次是否扩容

    简洁版:
    1.拿hash值
    2.判空
    3.创建新节点或者命中老节点
    4.按需扩容

    2.3.2 get方法解析

    1.7版本 get方法解析

    public V get(Object key) {
        if (key == null) // 1. 判空操作
            return getForNullKey();
        int hash = hash(key.hashCode()); //2. 计算hash值
        for (Entry<K,V> e = table[indexFor(hash, table.length)]; //3. 计算数组下标,遍历链表
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) //4. 命中返回值
                return e.value;
        }
        return null; //5. 没有命中,返回null
    }
    

    1.7版本的get操作可以总结为

    1.判空操作
    2.计算hash值
    3.计算数组下标,遍历链表
    4.命中返回值
    5.没有命中,返回null

    1.8版本 get方法解析

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value; //1.计算hash值
    }
    
    /**
     * Implements Map.get and related methods
     *
     * @param hash hash for key
     * @param key the key
     * @return the node, or null if none
     */
    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) { //2.数组判空,计算数组下标并取值判空
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k)))) //3.命中头节点
                return first;
            if ((e = first.next) != null) {
                if (first instanceof TreeNode) //4.命中红黑树节点,转红黑树操作
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do { //5.命中链表节点,遍历链表,命中则返回
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null; //6.数组为空,或者数组下标对应值为null,则返回null
    }
    

    1.8版本 get方法可以总结为以下几步

    1.计算hash值

    2.数组判空,计算数组下表并取值判空

    3.命中头节点,直接返回值

    4.命中红黑树节点,转红黑树操作

    5.命中链表节点,遍历链表,命中则返回

    6.数组为空,或数组下标对应值为空,则返回null

    简洁版:
    1.拿hash值
    2.判空
    3.命中节点(头节点,红黑树节点,链表节点)
    4.返回对应数据

    2.3.3 resize方法解析

    1.7版本 resize方法解析

    resize主要操作有两步
    1.根据老数组的长度确定新数组长度并新建一个新数组,新数组长度是老数组长度的二倍
    2.将老数组里的值通过重新hash操作命中到新数组中

    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length; //1.备份老数组长度,并执行边界合理判断操作
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }
    
        Entry[] newTable = new Entry[newCapacity];//2.创建新数组
        transfer(newTable); //3.新老数组数据转移
        table = newTable;
        threshold = (int)(newCapacity * loadFactor); //4.更新hash容量值
    }
    
    /**
     * Transfers all entries from current table to newTable.
     */
    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {//3.1 遍历数组
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity); //3.2 遍历链表,重新计算hash值,调整链表节点
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }
    

    1.7版本 resize方法可以总结为以下几步

    1.备份老数组长度,执行合理性判断

    2.创建新数组

    3.新老数组数据转移

    3.1遍历数组

    3.2遍历链表,重新计算hash值,调整链表节点

    4.更新hash容量值

    简洁版:
    1.创建新数组
    2.新老数组数据转移

    1.8版本 resize方法解析

    因为1.8版本,如果数组为null,会先执行一个扩容操作,所以1.8版本关于老数组的判断条件会多一些

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        int newCap, newThr = 0;
        if (oldCap > 0) {//1.老数组不为空,执行长度边界判断,以此确定新数组长度和hash容量
            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
        }
        //2.老数组为空,先确定扩容操作的初始容量和加载因子
        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) { //3.老数组不为空,遍历老数组执行rehash操作命中到新数组中
            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; //3.1 rehash过程中命中头结点
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap); //3.2 rehash操作命中红黑树节点
                    else { // preserve order
    		    //3.3 命中链表,遍历链表,不用重算hash值,直接重拍
                        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; //4.老数组为空,或者转移完毕,直接返回新数组
    }
    

    1.8版本 resize方法可以总结为以下几步

    1.老数组不为空,执行边界判断,以此确定新数组的长度和hash容量

    2.老数组为空,初始化初始容量和加载因子

    3.老数组不为空,遍历数组,执行新老数组数据转移操作

    3.1 命中头结点

    3.2 命中红黑树节点

    3.3 命中链表,直接根据老数组容量+偏移值即可命中新数组下标(这里下文详细讨论一下)

    4.老数组为空,或者转移完毕,返回新数组

    简洁版:
    同1.7

    2.3.4 hash方法解析

    1.7版本的 hash操作

    /**
     * Applies a supplemental hash function to a given hashCode, which
     * defends against poor quality hash functions.  This is critical
     * because HashMap uses power-of-two length hash tables, that
     * otherwise encounter collisions for hashCodes that do not differ
     * in lower bits. Note: Null keys always map to hash 0, thus index 0.
     */
    static int hash(int h) {
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }
    

    1.7版本hash操作的理解

    计算 key 的 hash 值。
    此算法加入了高位计算,防止低位不变,高位变化时,造成的 hash 冲突

    1.8版本的 hash操作

    /**
     * Computes key.hashCode() and spreads (XORs) higher bits of hash
     * to lower.  Because the table uses power-of-two masking, sets of
     * hashes that vary only in bits above the current mask will
     * always collide. (Among known examples are sets of Float keys
     * holding consecutive whole numbers in small tables.)  So we
     * apply a transform that spreads the impact of higher bits
     * downward. There is a tradeoff between speed, utility, and
     * quality of bit-spreading. Because many common sets of hashes
     * are already reasonably distributed (so don't benefit from
     * spreading), and because we use trees to handle large sets of
     * collisions in bins, we just XOR some shifted bits in the
     * cheapest possible way to reduce systematic lossage, as well as
     * to incorporate impact of the highest bits that would otherwise
     * never be used in index calculations because of table bounds.
     */
    static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    

    1.8版本hash操作的理解

    步骤 代码实现 分析
    计算哈希值 key.hashCode() 调用hashCode()方法,拿到初始hash值
    二次处理哈希值 h ^ (h >>> 16) 本质是高16位与低16位进行一个异或操作
    确定数组位置 (n - 1) & h n代表数组长度,h是计算出来的哈希值

    具体用例分析:

           key.hashCode() : 1111 1111 1111 1111 1111 0000 1110 1010
    ---------------------------------------------------------------
       
                        h : 1111 1111 1111 1111 1111 0000 1110 1010
                   h>>>16 : 0000 0000 0000 0000 1111 1111 1111 1111   计算hash
    
    hash = h ^ (h >>> 16) : 1111 1111 1111 1111 0000 1111 0001 0101
    ---------------------------------------------------------------
                            0000 0000 0000 0000 0000 0000 0000 1111  (n - 1)= 15,n初始容量16
                            1111 1111 1111 1111 0000 1111 0001 0101   hash值
           (n - 1) & hash : 0000 0000 0000 0000 0000 0000 0000 0101   结果是0101 即 下标为5
    

    2.3.5 indexFor方法解析

    1.7版本的indexFor方法解析

    /**
     * Returns index for hash code h.
     */
    static int indexFor(int h, int length) {
        return h & (length-1);
    }
    

    这个操作怎么理解呢,从最上面的文章里面介绍哈希表的时候,就说过,哈希表的映射关系才用的是除留取余法,简单说就是模运算

    在length为2的整数次幂时,h % length,实际结果跟h & (lenght - 1)值是一样的

    比如h=5,lenght = 8
    0000 0000 0000 0000 0000 0000 0000 0101 = 5
    0000 0000 0000 0000 0000 0000 0000 0111 = (8 - 1)
    0000 0000 0000 0000 0000 0000 0000 0101 = 5 结果就还是5

    由于与运算比模运算要快,所以这里才用的是与运算代替模运算,同时也可以解释为什么数组长度每次翻2的整数次幂

    为什么与运算比模运算要快?
    参考这篇为啥要用位运算代替取模呢,就是与运算转成汇编时要比模运算耗费的cpu周期少很多。但是这个例子举得C语言的。

    1.8版本同1.7,不多赘述。

    2.4 难点理解

    2.4.0 为什么加载因子是0.75

    1.HashMap基于哈希表实现,采用的是链地址法处理哈希冲突
    2.rehash操作由于需要重复创建数组以及重新计算地址,因此是一个非常耗时的操作

    有些文章说0.75和泊松分布有关,有些说跟泊松分布没关系,跟二项分布有关系

    觉得跟泊松分布有关系的文章认为,加载因子为0.75时,可以满足参数为0.5的泊松分布,但是又给不出来推导过程证明0.75和0.5的泊松分布有确切的数学关系。

    觉得跟泊松分布没有关系的文章认为,参数为0.5的泊松分布仅仅是为了解释为什么要在链表长度大于8时才转成红黑树,

    举个例子说明,HashMap默认的table[].length=16,在长度为16的HashMap中放入12(0.75*length)个数据,
    某一个bin中存放了8个节点的概率是0.00000006
    扩容一次,16*2=32,在长度为32的HashMap中放入24个数据,某一个bin中存放了8个节点的概率是0.00000006
    再扩容一次,32*2=64,在长度为64的HashMap中放入48个数据,某一个bin中存放了8个节点的概率是0.00000006
    

    至于为什么是0.75,他们认为大于0.75会导致哈希冲突增加,性能不好,小于0.75会导致浪费空间发生多次resize影响效率。
    认为0.75只是一个折中选择,还有说一个bin为空还是非空的概率为0.5,通过牛顿二项式计算得到结果为log(2),也只能说是一种猜测。

    2.4.1 为什么链表长度为8,并且数组长度大于64时时开始扩展

    从java注释来看,这个跟一个统计学里很重要的原理——泊松分布有关。

    泊松分布是统计学和概率学常见的离散概率分布,适用于描述单位时间内随机事件发生的次数的概率分布。

    \[P(N(t) = n) = \frac{e^{-λt}{(λt)}^{n}}{n!} \]

    1.Lambda是在一定的时间/空间内,事件发生的平均值
    
    2.e是自然常数2.71828...
    
    3.n是事件在这一段时间/空间内发生的次数
    
    4.P是该事件在这段时间/空间内发生的概率
    

    在理想情况下,使用随机哈希码,在扩容阈值(加载因子)为0.75的情况下,节点出现在频率在Hash桶(表)中遵循参数平均为0.5的泊松分布。
    忽略方差,即X = λt,P(λt = k),其中λt = 0.5的情况,按公式:

    \[P(X = k) = \frac{e^{-0.5} 0.5^k}{k!}, k = 0,1,2,3... \]

    计算结果如上述的列表所示,当一个bin(可以理解为HashMap table[]中任意一个元素对应的集合)中的链表长度达到8个元素的时候,概率为0.00000006,几乎是一个不可能事件。
    所以我们可以知道,其实常数0.5是作为参数代入泊松分布来计算的,而加载因子0.75是作为一个条件,当HashMap长度为length/size ≥ 0.75时就扩容,

    (这里就很难理解了,哪里能看出来0.75是一个条件呢?)
    在这个条件下,冲突后的拉链长度和概率结果为:

    0:    0.60653066
    1:    0.30326533
    2:    0.07581633
    3:    0.01263606
    4:    0.00157952
    5:    0.00015795
    6:    0.00001316
    7:    0.00000094
    8:    0.00000006
    

    加载因子是0.75,决定了桶中元素到达 8 个的时候概率很小,进而转为红黑树;而不是到达 8 个的时候概率很小所以加载因子是0.75。
    (这个是怎么决定的呢,很多文章说并不是这个0.75决定的,我反正是持怀疑态度)


    2.4.2 HashMap 初始大小为何是 16

    每当插入一个元素时,我们都需要计算该值在数组中的位置,即p = tab[i = (n - 1) & hash]。
    当 n = 16 时,n - 1 = 15,二进制为 1111,这时和 hash 作与运算时,元素的位置完全取决与 hash 的大小
    倘若不是 16,如 n = 10,n - 1 = 9,二进制为 1001,这时作与运算,很容易出现重复值,如 1101 & 1001,1011 & 1001,1111 & 1001,结果都是一样的,所以选择 16 以及 每次扩容都乘以二的原因也可想而知了

    2.4.3 1.8版本扩容优化分析


    情况1:扩容后,若hash值 新增参与运算的位 = 0,那么元素在扩容后的位置 = 原始位置

    扩容前后 数组长度-1
    (n-1)
    key1对应的hash值
    (hash1)
    key1对应的数组下标值
    (hash1 & (n - 1))
    扩容前
    (容量=16)
    0000 0000 0000 0000 0000 0000 0000 1111 1111 1111 1111 1111 1111 0000 1111 0000 0101 1111 1111 1111 1111 1111 0000 1111 0000 0101 = 5
    扩容后
    (容量=32)
    0000 0000 0000 0000 0000 0000 0001 1111
    (扩容后会增多一位,高位为1)
    1111 1111 1111 1111 1111 0000 1111 0000 0101
    (新增参与运算的位=0)
    1111 1111 1111 1111 1111 0000 1111 0000 0101 = 5
    (扩容后的位置=原位置)

    情况2:扩容后,若hash值 新增参与运算的位 = 1,那么元素在扩容后的位置 = 原始位置 + 扩容前的旧容量

    扩容前后 数组长度-1
    (n-1)
    key2对应的hash值
    (hash2)
    key2对应的数组下标值
    (hash2 & (n - 1))
    扩容前
    (容量=16)
    0000 0000 0000 0000 0000 0000 0000 1111 1111 1111 1111 1111 1111 0000 1111 0001 0101 1111 1111 1111 1111 1111 0000 1111 0000 0101 = 5
    扩容后
    (容量=32)
    0000 0000 0000 0000 0000 0000 0001 1111
    (扩容后会增多一位,高位为1)
    1111 1111 1111 1111 1111 0000 1111 0001 0101
    (新增参与运算的位 = 0)
    1111 1111 1111 1111 1111 0000 1111 0001 0101 = 5 + 16
    (扩容后的位置 = 原位置 + 扩容前的旧容量)

    2.4.4 多线程安全问题分析

    这篇文章说的很详细,不在赘述。疫苗:JAVA HASHMAP的死循环

    3.参考文档

    面试官:哈希表都不知道,你是怎么看懂HashMap的?

    疫苗:JAVA HASHMAP的死循环

    Java 程序员都该懂的 HashMap

    Java源码分析:HashMap 1.8 相对于1.7 到底更新了什么?

    Java 集合 - HashMap 解析

    为什么 HashMap 的加载因子是0.75?我研究源码发现一个重大秘密。。。

    HashMap深度解释推导

    为啥要用位运算代替取模呢

  • 相关阅读:
    ASP.NET Core 使用Redis存储Session
    JS复制文本到剪切板
    Linux 升级修改libc gcc 文件名称,导致执行命令失效问题解决
    Linux 基础命令-CURL 表单上传文件
    CentOS 下部署 ASP.NET Core环境
    ASP.NET Core 添加日志NLog
    Windows 下TortoiseGit 设置避免每次登录帐号密码
    类加载机制与双亲委派
    句子的成分
    词的作用
  • 原文地址:https://www.cnblogs.com/cfdroid/p/16303599.html
Copyright © 2020-2023  润新知