HashMap:从源码分析到面试题

1 HashMap简介

HashMap是实现map接口的一个重要实现类,在我们无论是日常还是面试,以及工作中都是一个经常用到角色。它的结构如下:

HashMap:从源码分析到面试题插图

它的底层是用我们的哈希表和红黑树组成的。所以我们在学习HashMap底层原理的时候,需要有这两种数据结构的知识做铺垫,才能有更好的理解!

1.1 哈希表

散列表是由我们的数组链表组成的,集成了两种数据结构的优点,我们先简单介绍一下这两种数据结构。

数组:数组存储区间是连续的,占用内存严重,故空间复杂度很大,但数组的二分查找时间复杂度很小,为 o(1),数组的特点:查找速度快、插入和删除效率低

链表:链表存储区间离散,占用内存比较宽松,故空间复杂度很小,但时间复杂度很大,为 o(n),链表的特点:查找速度慢、插入和删除效率高

哈希表:哈希表为每个对象计算出一个整数,称为哈希码根据这些计算出来的整数(哈希码)保存在对应的位置上!如果遇到了哈希冲突,也就是同一个坑遇到了被占用的情况下,那么我们就会以链表的形式添加在后面。

HashMap:从源码分析到面试题插图(1)

1.2 红黑树

关于红黑树的知识点比较多,如果过多介绍红黑树的话,那么HashMap就不好介绍了。这里给上一个连接,一篇关于红黑树非常好的文章。点击这里

2 源码解析

好了,开始解析我们的源码,通过解析源码更好的了解HashMap后,对那么常见的面试题也可以更加的吃透!

2.1 基本属性

首先就是介绍我们的HashMap的基本属性,对基本属性介绍完之后,对后面方法里使用时才不会迷惑

1、我们的默认的初始化的hashmap的容量,如果没有指定的话,就是我们的默认,1<<4就是16。

    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

2、我们的hashmap最大容量,2的30次方。

    static final int MAXIMUM_CAPACITY = 1 << 30;

3、默认的装载因子,0.75。有什么用呢?比如我们的容量现在是16,16*0.75=12,也就是说,当我们的实际容量到了12的时候,那么就会触发扩容机制,进行扩容!

    static final float DEFAULT_LOAD_FACTOR = 0.75f;

4、我们知道哈希表是由数组和链表组成的,每一个位置都可以说是一个哈希桶。我们的哈希桶默认是链表,但是在JDK1.8之后我们的哈希桶中当有TREEIFY_THRESHOLD个节点的时候,也就是下面默认的8,我们桶中的链表会被转换为红黑树的结构。

    static final int TREEIFY_THRESHOLD = 8;

5、与上面相同,不过不同的是,会将红黑树转换成链表。

    static final int UNTREEIFY_THRESHOLD = 6;

6、当哈希桶的结构转换成树之前,还会有一次判断,只有键值对大于64才会转换!也就是我们下面定义的最小容量,这是为了避免哈希表建立初期多个键值对恰巧都在一个哈希桶上面,而导致了没必要的转换。

    static final int MIN_TREEIFY_CAPACITY = 64;

7、内部结构静态内部类
HashMap:从源码分析到面试题插图(2)

8、其他成员变量
HashMap:从源码分析到面试题插图(3)

2.1.1 思考

这里同时引发了我们一些思考?为什么要将转换成树形结构的阈值设置为8呢?为什么不将转换成链表结构的阈值也设置为8呢?这里我们在最后面试题分析的时候统一进行回答!

2.2 构造方法

hashmap的构造方法有四个,不过我们重点介绍其中的一个,因为这一个理解了,其他的也不成问题。

//initialCapacity:初始大小
//loadFactor:装载因子    
public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
        this.loadFactor = loadFactor;
        this.threshold = tableSizeFor(initialCapacity);
    }

总结了构造方法进行的操作:

  1. 首先是边界处理,如果初始大小小于0,抛异常。如果大于最大,那也只能赋予我们默认的最大值!如果装载因子小于0或者不是数字的话,抛异常!
  2. 然后就是进行我们的赋值,装载因子赋值,还有就是调用我们的tableSizeFor来返回一个大于等于initialCapacity的2次幂。
    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;
    }

关于为什么做了位运算后可以返回大于等于它的二次幂,可以看一下这篇博文!点击跳转

这里的threshold也就是我们的阈值,当达到了这个阈值的时候我们会进行扩容!但是这里可能也会觉得疑惑,阈值不是容量*装载因子吗?不应该写成下面这样子吗?

this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;

注意,在构造方法中,并没有对table这个成员变量进行初始化,table的初始化被推迟到了put方法中,在put方法中会用到resize()方法,然后对threshold重新计算。后面我们对方法分析时会谈到。

2.3 核心方法

关于hashmap和核心方法和考点,其实都集中在put方法和resize()方法,这也会是我们下面重点要介绍到的。

2.3.1 put方法

我们首先来看put方法

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

调用了我们的putval方法,参入了一个以key计算的哈希值,key,value,还有两个其他参数。在看putVal方法之前先来看一下hash方法,看看它是如何计算哈希值。

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

这是一个三目运算符,如果key不为null的话,返回我们的key的哈希值(低十六位)同时与高16位的异或运算。这一步的操作意义何为呢?我们先临时跳到putVal方法里面可以看到有这么一步操作

HashMap:从源码分析到面试题插图(4)

它将我们计算出来的哈希值,与我们的哈希表长度-1(为了获得)进行&运算,这是为了获取我的table下标。至于为什么-1呢?因为我们的长度都是2的整数次幂,转换成2进制也就是1000000….这种的形式,为了更好的随机,所有我们进行了-1操作,也就是变成11111111这种。因为&操作是都为1的时候才会为1,所以我的的1多的时候随机性才会更大,毕竟一个1能干过那么多的1吗?这是减少哈希冲突的第一步操作。举个例子说明一下:

比如我们的长度转换为2进制为 1000 0000 ,进行-1操作后就是 0111 1111
而这个时候我们原来的二进制数
1000 0000
&
0101 1011 = 0000 0000
与任何最高位不为1的数进行&运算,都会变成0,也就让我们的哈希冲突变大了!
而我们-1操作后
0111 1111
&
0101 1011 = 0101 1011
可以看出来,这样比原来的减少了很多的哈希冲突。
同时这也是为什么我们要让哈希的容量大小一定要为2的整数次幂

好了,我们要回答一下再上面那个问题了,为什么要返回低16位与高16位的异或作为key的最终hash值呢?同样举个例子演示一下这个流程:

假设length为8,HashMap的默认初始容量为16;

length = 8 ,(length-1) = 7 , 转换二进制为111;

假设一个key的 hashcode = 78897121 ,转换二进制:100101100111101111111100001,与(length-1)& 运算如下

    0000 0100 1011 0011 1101 1111 1110 0001
 
&运算
 
    0000 0000 0000 0000 0000 0000 0000 0111
 
=   0000 0000 0000 0000 0000 0000 0000 0001 (就是十进制1,所以下标为1)

上述运算实质是:001 与 111 & 运算。也就是哈希值的低三位与length与运算。如果让哈希值的低三位更加随机,那么&结果就更加随机,就更能减少我们的哈希冲突了。如何让哈希值的低三位更加随机,那么就是让其与高位异或,所以我们才在返回的时候与高位异或了再返回。低位与高位异或的过程举个例子如下:

HashMap:从源码分析到面试题插图(5)

然后总结一下在与我们与哈希值进行运算的时候有这么一个规律:

  • 当length=8时 下标运算结果取决于哈希值的低三位

  • 当length=16时 下标运算结果取决于哈希值的低四位

  • 当length=32时 下标运算结果取决于哈希值的低五位

  • 当length=2的N次方, 下标运算结果取决于哈希值的低N位。

好了,我们继续回到我们的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为空的时候调用resize()进行扩容初始化
        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;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //hashcode和key相等,记录下原先的值
                e = p;
            //如果这个时候我们的哈希桶已经是红黑树结构,那么调用树的插入函数
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //链表结构,同时我们的hashcode不相等
                //找到与key相等的节点,更新value,退出循环
                //如果没有找到与key相等的节点,在链表尾部插入,如果插入后节点数量大于
                //我们变成红黑树的阈值,那么进行转换成红黑树
                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;
                    }
                    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;
                //空实现,为LinkedHashMap预留
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        //键值对达到阈值,进行扩容
        if (++size > threshold)
            resize();
        //空实现,为LinkedHashMap预留
        afterNodeInsertion(evict);
        return null;
    }

2.3.2 resize()方法

我们在上面不管是源码分析还是在哪分析,都说到了我们的resize()方法,下面我们将正式开始讲到

   final Node<K,V>[] resize() {
    	//原table数组赋值
        Node<K,V>[] oldTab = table;
    	//如果原数组为null,那么原数组长度为0
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
    	//赋值阈值
        int oldThr = threshold;
    	//newCap 新数组长度
    	//newThr 下次扩容的阈值
        int newCap, newThr = 0;
    	// 1. 如果原数组长度大于0
        if (oldCap > 0) {
            //如果大于最大长度1 << 30 = 1073741824,那么阈值赋值为Integer.MAX_VALUE后直接返回
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 2. 如果原数组长度的2倍小于最大长度,并且原数组长度大于默认长度16,那么新阈值为原阈值的2倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
    	// 3. 如果原数组长度等于0,但原阈值大于0,那么新的数组长度赋值为原阈值大小
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            // 4. 如果原数组长度为0,阈值为0,那么新数组长度,新阈值都初始化为默认值
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
    	// 5.如果新的阈值等于0
        if (newThr == 0) {
            //计算临时阈值
            float ft = (float)newCap * loadFactor;
            //新数组长度小于最大长度,临时阈值也小于最大长度,新阈值为临时阈值,否则是Integer.MAX_VALUE
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
    	//计算出来的新阈值赋值给对象的阈值
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
    	//用新计算的数组长度新建一个Node数组,并赋值给对象的table
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
    	//后面是copy数组和链表数据逻辑
        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;
    }

这个时候我们以最初的三种构造方法来模拟一下流程。上面每一个扩容情况都标注了记号

//①
Map<String, String> map = new HashMap<>();
map.put("1", "1");
//②
Map<String, String> map1 = new HashMap<>(2);
map1.put("2", "2");
//③
Map<String, String> map2 = new HashMap<>(2, 0.5f);
map2.put("3", "3");
  • ① 没有设置initialCapacity,也没有设置负载因子,第一次put的时候会触发扩容。第一次的时候,数组长度为默认值16,阈值为160.75=12,走的代码4逻辑,等到数组长度超过阈值12后,触发第二次扩容,此时table数组,和threshold都不为0,即oldTab、oldCap、oldThr都不为0,先走代码1,如果oldCap长度的2倍没有超过最大容量,并且oldCap 长度大于等于 默认容量16,那么下次扩容的阈值 变为oldThr大小的两倍即 12 2 = 24,newThr = 24,newCap=32
  • ② 设置了initialCapacity,没有设置负载因子,此时hashMap使用默认负载因子0.75,本实例设置的初始容量为2,通过计算阈值为2,第一次put的时候由于还没初始化table数组,因此触发第一次扩容。此时oldCap为0,oldThr为2,走代码3,确定这次扩容的新数组大小为2,此时还没有确定newThr 下次扩容的大小,于是进入代码5 确定newThr为 2 0.75 = 1.5 取整 1 ,及下次扩容阈值为1。当数组已有元素大于阈值及1时,触发第二次扩容,此时oldCap为1,oldThr为1,走代码1newCap = oldCap << 1 结果为 4 小于最大容量, 但oldCap 小于hashMap默认大小16,结果为false,跳出判断,此时由于newThr等于0,进入代码5,确定newThr为 4 0.75 = 3,下次扩容阈值为3
  • ③ 设置了initialCapacity=2,负载因子为0.5,通过tableSizeFor计算阈值为2,第一次put的时候,进行扩容,此时oldCap为2,oldThr为2,进入代码1,同实例②,newCap = oldCap << 1 结果为 4 小于最大容量, 但oldCap 小于hashMap默认大小16,结果为false,跳出判断,进入代码5,确定newThr为 4 * 0.5 = 2,下次扩容阈值为2

2.3.3 get()方法

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

获取了我们的key的hashcode然后作为参数传入getNode方法中!

    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);
            }
        }
        //如果没有找到的话,返回null
        return null;
    }

2.3.4 remove方法

    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }

首先是计算出我们的hash,然后调用removeNode方法来移除

    final Node<K,V> removeNode(int hash, Object key, Object value,
                               boolean matchValue, boolean movable) {
        Node<K,V>[] tab; Node<K,V> p; int n, index;
        //我们的哈希桶不为空,同时要映射的哈希值也在
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (p = tab[index = (n - 1) & hash]) != null) {
            Node<K,V> node = null, e; K k; V v;
            //刚好我们的哈希桶首位就是要删除的,记录下来
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            //如果不是,进行遍历查找
            else if ((e = p.next) != null) {
                //如果是红黑树结构的话,调用树的查找方法
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    //对链表进行查找key
                    do {
                        if (e.hash == hash &&
                            ((k = e.key) == key ||
                             (key != null && key.equals(k)))) {
                            node = e;
                            break;
                        }
                        p = e;
                    } while ((e = e.next) != null);
                }
            }
            //找到了之后就去删除,分红黑树,桶的首位,链表中,
            if (node != null && (!matchValue || (v = node.value) == value ||
                                 (value != null && value.equals(v)))) {
                //红黑树,调用树删除节点的方法
                if (node instanceof TreeNode)
                    ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                //在桶首位,直接将下一个节点赋值给首位
                else if (node == p)
                    tab[index] = node.next;
                //在链表中,将下一个结点赋值给前一个节点的下一个节点,删除自我
                else
                    p.next = node.next;
                ++modCount;
                --size;
                afterNodeRemoval(node);
                return node;
            }
        }
        return null;
    }

3 总结

  1. 扩容是一个特别耗性能的操作,所以当我们在使用 HashMap,正确估算 map 的大小,初始化的时候给一个大致的数值,避免 map 进行频繁的扩容。

  2. 负载因子 loadFactor 是可以修改的,也可以大于1,但是建议不要轻易修改,除非情况特殊。

  3. HashMap 是非线程安全的,不要在并发的情况下使用 HashMap,建议使用 ConcurrentHashMap!

4 面试题分析

关于HashMap的源码就分析这些,因为这些足够我们去了解它的一些基本特性和常见面试足够用了。下面我收集了一些面试题和我们上面的留下的思考题进行分析!

1、为什么要将转换成树形结构的阈值设置为8呢?为什么不将转换成链表结构的阈值也设置为8呢?

  1. 当初始阈值为8时,链表的长度达到8的概率变的很小,如果再大概率减小的并不明显

  2. 树结构查找的时间复杂度是O(log(n)),而链表的时间复杂度是O(n),当阈值为8时,long8 = 3,相比链表更快,但树结构比链表占用的空间更多,所以这是一种时间和空间的平衡

至于为什么不将转换链表的阈值也设置为8,是因为如果两个值太接近的话,就会造成频繁的转换,导致我们的时间复杂度变高。而在6是经过计算后最合适的数值

2、HashMap 为什么不用平衡树,而用红黑树?

这一题应该归类与数据结构了,不过这里同样给出分析

  • 红黑树也是一种平衡树,但不是严格平衡,平衡树是左右子树高度差不超过1,红黑树可以是2倍

  • 红黑树在插入、删除的时候旋转的概率比平衡树低很多,效率比平衡树高

查找时间复杂度都维持在O(logN),具体的还望查看红黑树的特性,上面最开始也给了一篇关于红黑树的介绍。

3、HashMap在并发下会产生什么问题?有什么替代方案?

HashMap并发下产生问题:由于在发生hash冲突,插入链表的时候,多线程会造成环链,再get的时候变成死循环,Map.size()不准确,数据丢失。

关于为什么会造成环链的话,可以看这里!

替代方案:

  • HashTable: 通过synchronized来修饰,效率低,多线程put的时候,只能有一个线程成功,其他线程都处于阻塞状态
  • ConcurrentHashMap:
    1.7 采用锁分段技术提高并发访问率
    1.8 数据依旧是分段存储,但锁采用了synchronized

4、HashMap中的key可以是任何对象或数据类型吗?

  • 可以是null,但不能是可变对象,如果是可变对象,对象中的属性改变,则对象的HashCode也相应改变,导致下次无法查找到已存在Map中的数据

  • 如果要可变对象当着键,必须保证其HashCode在成员属性改变的时候保持不变

5、为什么不直接将key作为哈希值而是与高16位做异或运算?

这个我们在上面说过了,还用图和样例解释,是为了更好的随机性,解决哈希碰撞。

6、关于更多的面试题

这里提供了一篇关于面试题挺多的博文,通过阅读源码,里面大部分的面试题都可以解答了!

点击这里看面试题

5 HashMap与HashTable有什么不同?

因为HashTable和HashMap很是类似,就跟我们的Vector与ArrayList的关系一样。提供了线程安全的解决方案,所有我们在这里通过区别,就相当与对HashTable进行了源码分析!

从存储结构和实现来讲基本上都是相同的。

它和HashMap的最大的不同是它是线程安全的,另外它不允许key和value为null。

Hashtable是个过时的集合类,不建议在新代码中使用,不需要线程安全的场合可以用HashMap替换,需要线程安全的场合可以用ConcurrentHashMap替换或者Collections的synchronizedMap方法使HashMap具有线程安全的能力。

不同点 HashMap HashTable
数据结构 数组+链表+红黑树 数组+链表
继承的类不同 继承AbstractMap 继承Dictionary
是否线程安全
性能高低
默认初始化容量 16 11
扩容方式不同 原始容量*2 原始容量*2+1
底层数组的容量为2的整数次幂 要求为2的整数次幂 不要求
确认key在数组中的索引的方法不同 i = (n – 1) & hash; index = (hash & 0x7FFFFFFF) % tab.length;
遍历方式 Iterator(迭代器) Iterator(迭代器)和Enumeration(枚举器)
Iterator遍历数组顺序 索引从小到大 索引从大到小

6 参考资料

公众号《Java3y》文章

知乎专栏《Java那些事儿》

阿提说说

4.Java容器-HashMap详解

HashMap源码注解 之 静态工具方法hash()、tableSizeFor()(四)

HashMap中hash(Object key)原理,为什么(hashcode >>> 16)。

本站资源均源自网络,若涉及您的版权、知识产权或其他利益,请附上版权证明邮件告知。收到您的邮件后,我们将在72小时内删除。
若下载资源地址错误或链接跳转错误请联系站长。站长q:770044133。

» HashMap:从源码分析到面试题

发表评论

免登录下载网,提供全网最优质的资源集合!