【Java集合】HashMap源码分析

已于 2022-03-09 23:50:11 修改
阅读量227 收藏
点赞数 1
文章标签： java 集合 hashmap
于 2022-01-20 20:07:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41403171/article/details/122608956
版权

HashMap

文章目录

1、类图

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

在这里插入图片描述

2、属性

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

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

// 默认负载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

// 链表转红黑树阈值
static final int TREEIFY_THRESHOLD = 8;

// 红黑树转链表阈值
static final int UNTREEIFY_THRESHOLD = 6;

// 树化数组大小阈值
static final int MIN_TREEIFY_CAPACITY = 64;

// 存储数据的数组
transient Node<K,V>[] table;

// 用于保存缓存的 entrySet()
transient Set<Map.Entry<K,V>> entrySet;

// 元素个数
transient int size;

// 操作次数
transient int modCount;

// 扩容阈值(元素个数超过这个数量就进行扩容)
int threshold;

// 负载因子
final float loadFactor;

3、内部节点

// 单链表节点
static class Node<K,V> implements Map.Entry<K,V> {
    // hash值
    final int hash;
    // 键key
    final K key;
    // 值value
    V value;
    // 下一个节点
    Node<K,V> next;

    // 方法忽略。。。
}

在这里插入图片描述

// 红黑树节点(后续会专门说明)
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
}

4、构造器

// 无参构造(默认加载因子为 0.75)
public HashMap() {
    this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}

// 指定初始容量和默认加载因子 (0.75)
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

// 指定初始容量和负载因子
public HashMap(int initialCapacity, float loadFactor) {
    // 校验 initialCapacity 参数
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    // 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);
}

// 返回一个比给定整数大且最接近的2的幂次方整数(10 -> 16)
// 原理就是将传进来的数-1后转二级制，将第一个1之后的位全变为1，再+1,保证是大于原数且是2的幂次方整数
static final int tableSizeFor(int cap) {
    // 防止传进来的数就是2的幂次方，导致翻倍就先-1(10 - 1 = 9)
    int n = cap - 1;
    // n 等于 n 与 n逻辑右移一位的值进行或运算 (n = 0000 1001 | 0000 0100 = 0000 1101)
    n |= n >>> 1;
    // 同理 (n = 0000 1101 | 0000 0011 = 0000 1111),之后同理
    n |= n >>> 2;
    n |= n >>> 4;
    n |= n >>> 8;
    n |= n >>> 16;
    // 这里最后返回(n = n + 1, n = 0000 1111 + 1 = 0001 0000 = 16)
    return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
// 构造一个与指定 Map 具有相同映射的新 HashMap。 HashMap 是使用默认加载因子 (0.75) 和足以容纳指定 Map 中的映射的初始容量创建的
public HashMap(Map<? extends K, ? extends V> m) {
    this.loadFactor = DEFAULT_LOAD_FACTOR;
    putMapEntries(m, false);
}

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
    int s = m.size();
    if (s > 0) {
        // 如果 table 为空，说明还没初始化,先初始化
        if (table == null) { // pre-size
            // 根据 s 的大小 + loadFactor 负载因子，计算需要最小的 tables 大小
            float ft = ((float)s / loadFactor) + 1.0F;
            int t = ((ft < (float)MAXIMUM_CAPACITY) ?
                     (int)ft : MAXIMUM_CAPACITY);
            if (t > threshold)
                threshold = tableSizeFor(t);
        }
        // 如果s > 扩容阈值
        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);
        }
    }
}

5、哈希值

// 获得hash值
static final int hash(Object key) {
    int h;
    // h = key.hashCode() 计算哈希值
    // ^ (h >>> 16) 高 16 位与自身进行异或计算，保证计算出来的 hash 更加离散
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

6、添加单个元素

// 添加单个元素
public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}

/**
* hash 			key的哈希值
* key  			key
* value 		value
* onlyIfAbsent 	是否更改现有值(true不改，false)
* evict 		表是否处于创建状态(true不是。false是创建状态)
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
               boolean evict) {
    // 数组
    Node<K,V>[] tab; 
    // 对应位置的节点
    Node<K,V> p; 
    // 数组长度n,数组下标i
    int n, i;
    // 如果数组为空，或长度为0，进行扩容
    if ((tab = table) == null || (n = tab.length) == 0)
        // 扩容
        n = (tab = resize()).length;
    // 如果数组对应下标的值为null,直接插入(p = 对应数组下标链表的头结点)
    if ((p = tab[i = (n - 1) & hash]) == null)		
        // 创建一个新节点放到对应位置
        tab[i] = newNode(hash, key, value, null);
    // 如果对应位置的值不为空
    else {
        // 对应位置的老节点
        Node<K,V> e; K k;
        // 如果头结点的hash值和key值与要插入的相同
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            // 将e = 对应位置的老节点，后面将值替换
            e = p;
        // 如果头结点是红黑树
        else if (p instanceof TreeNode)
            // 调用树的插入逻辑
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        // 走到这里说明是链表类型
        else {
            // 进行遍历
            for (int binCount = 0; ; ++binCount) {
                // 从头结点的下一个节点开始(e = p.next)
                // 如果已经遍历到链表的尾巴，则说明 key 在 HashMap 中不存在，则需要创建
                if ((e = p.next) == null) {
                    // 创建新的 Node 节点
                    p.next = newNode(hash, key, value, null);
                    // 判断你是否达到树化条件(链表长度是否达到8)
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        // 树化
                        treeifyBin(tab, hash);
                    break;
                }
                // 如果遍历的 e 节点，就是要找的，则直接返回
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                // p = p.next
                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;
}

// 树化
final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // 如果 table 容量小于 MIN_TREEIFY_CAPACITY(64) ，则选择扩容
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
        resize();
    // 满足树化条件，进行树化
    else if ((e = tab[index = (n - 1) & hash]) != null) {
        // 顺序遍历链表，逐个转换成 TreeNode 节点
        TreeNode<K,V> hd = null, tl = null;
        do {
            TreeNode<K,V> p = replacementTreeNode(e, null);
            if (tl == null)
                hd = p;
            else {
                p.prev = tl;
                tl.next = p;
            }
            tl = p;
        } while ((e = e.next) != null);
        // 树化
        if ((tab[index] = hd) != null)
            hd.treeify(tab);
    }
}

7、扩容

// 扩容
final Node<K,V>[] resize() {
    // 原数组
    Node<K,V>[] oldTab = table;
    // 原数组长度
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 原扩容阈值
    int oldThr = threshold;
    // 初始化新数组长度，扩容阈值
    int newCap, newThr = 0;
    // 如果原数组长度大于0，说明table非空
    if (oldCap > 0) {
        // 数组长度大于最大容量
        if (oldCap >= MAXIMUM_CAPACITY) {
            // 扩容阈值设置最大
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
        // 正常扩容为原来的两倍(oldCap << 1)
       	// 如果扩容后小于最大容量且oldCap >= DEFAULT_INITIAL_CAPACITY 满足，说明当前容量大于默认值（16），则 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
        // 数组长度等于默认值16
        newCap = DEFAULT_INITIAL_CAPACITY;
        // 扩容阈值等于默认长度 * 负载因子
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 如果上述的逻辑，未计算新的阀值，则使用 newCap * loadFactor 作为新的阀值
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }
    // 将 newThr 赋值给 threshold 属
    threshold = newThr;
    @SuppressWarnings({"rawtypes","unchecked"})
    // 创建新的 Node 数组，赋值给 table 属性
    Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    // 如果原数组不为空，需要将原数组数据迁移
    if (oldTab != null) {
        // 遍历数组
        for (int j = 0; j < oldCap; ++j) {
            // 获得老的 table 数组第 j 位置的头节点 e
            Node<K,V> e;
            // 当头结点不为空时
            if ((e = oldTab[j]) != null) {
                // 将老数组j下标的节点置空
                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
                    // HashMap 是成倍扩容，这样原来位置的链表的节点们，会被分散到新的 table 的两个位置中去
                    // 通过 e.hash & oldCap 计算，根据结果分到高位、和低位的位置中。
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    // 遍历链表
                    do {
                        // 指向下一个节点
                        next = e.next;
                        // e.hash & oldCap=0表示的是所有原hash的第指数+1位,通过这个结果(1-高位，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);
                    // 设置低位到新的 newTab 的 j 位置上
                    if (loTail != null) {
                        loTail.next = null;
                        newTab[j] = loHead;
                    }
                     // 设置高位到新的 newTab 的 j + oldCap 位置上
                    if (hiTail != null) {
                        hiTail.next = null;
                        newTab[j + oldCap] = hiHead;
                    }
                }
            }
        }
    }
    return newTab;
}

8、添加多个元素

// 将所有映射从指定映射复制到此映射
public void putAll(Map<? extends K, ? extends V> m) {
    putMapEntries(m, true);
}

9、查找单个元素

// 根据key获取value
public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}
// 根据哈希值和key获取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;
}

10、单个删除

// 根据key移除元素，返回对应的value值
public V remove(Object key) {
    Node<K,V> e;
    // 调用移除节点方法，如果不为空，返回具体值，否则返回nulls
    return (e = removeNode(hash(key), key, null, false, true)) == null ?
        null : e.value;
}


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;
    // 根据hash值，查找table下标的头节点
    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 {
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        // 如果找到节点进行删除操作
        // 如果有要求匹配 value 的条件，这里会进行一次判断先移除
        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;
            // 是链表的中间节点，将p节点指向要删除节点的下一个节点
            else
                p.next = node.next;
            // 操作次数+1
            ++modCount;
            // 元素个数-1
            --size;
            // 移除 Node 后的回调
            afterNodeRemoval(node);
            // 返回 node
            return node;
        }
    }
    // 查找不到，则返回 null
    return null;
}

11、红黑树

见下一期手写红黑树

斯内克喜欢吃益达
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中的HashMap源码分析
Palpitate_fx的博客
03-27 638
目录 HashMap的继承体系 什么是Map 哈希表 存储结构 HashMap的属性 Node内部类 HashMap的构造方法 数组容量的计算 put( K key,V value)方法 HashMap的扩容机制 HashMap新的数组的填充 HashMap的get操作 HashMap 中的红黑树 散列冲突解决方式 HashMap的继承体系 1.HashMap实现了Serializable接口，可以被序列化 2.HashMap实现了Cloneable接口，可..
Java集合系列之HashMap源码分析
08-27
Java集合系列之HashMap源码分析 Java集合系列之HashMap源码分析是Java集合系列中的一篇非常重要的文章，它详细介绍了Java集合系列之HashMap源码，具有很高的参考价值。下面我们将对HashMap源码进行详细的分析。 ...
java HashMap 源码分析（深度讲解）
Cyan_RA9的博客
03-27 1543
java 集合篇章——HashMap源码分析（非常详细）。
Java集合之HashMap源码分析
程序员随笔
01-07 2275
  前面我们提到了集合，今天我们就具体来了解一下Java集合中具体的组成部分！   以下源码均为jdk1.7 HashMap概述 HashMap是基于哈希表的Map接口的非同步实现. 提供所有可选的映射操作, 并允许使用null值和null健. 此类不保证映射的顺序. 需要注意的是: HashMap不是同步的. 哈希表 哈希表定义: 哈希表是一种根据关键码去寻找值的数据映射结构...
Java HashMap 源码分析
BusyMonkey
07-17 969
https://www.cnblogs.com/chengxiao/p/6059914.html   哈希表（hash table）也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，而HashMap的实现原理也常常出现在各类的面试题中，重要性可见一斑。本文会对java集合框架中的对应实现HashMap的实现原...
java集合 hashMap源码分析及底层实现储存过程 这一篇就够了
小码农吗
09-15 2801
一、前言 1.什么事hash？ 个人认为hash概念 就是把任意长度的输入通过一个hash算法之后，映射成固定长度的输出 当两个key通过hashCode计算相同时，则发生了hash冲突(碰撞)，HashMap解决hash冲突的方式是用链表。 2.解决hash冲突 当发生hash冲突时，则将存放在数组中的Entry设置为新值的next（这里要注意的是，比如A和B都hash后都映射到下标i中，之前已经有A了，当map.put(B)时，将B放到下标i中，A则为B的next，所以新值存放在数组中
Java-HashMap源码
ALONG的博客
02-26 598
简介   HashMap 主要用来存放键值对，它基于哈希表的 Map 接口实现，是常用的 Java 集合之一，是非线程安全的。   HashMap 可以存储 null 的 key 和 value，但 null 作为键只能有一个，null 作为值可以有多个。   JDK1.8 之前 HashMap 由 数组+链表 组成的，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的（“拉链法”解决冲突）。    JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值（
Java集合之一—HashMap
热门推荐
深入浅出学JAVA
11-02 60万+
深入浅出学Java——HashMap 哈希表（hash table） 也叫散列表，是一种非常重要的数据结构，应用场景及其丰富，许多缓存技术（比如memcached）的核心其实就是在内存中维护一张大的哈希表，本文会对java集合框架中的对应实现HashMap的实现原理进行讲解，然后会对JDK7的HashMap源码进行分析。 一、什么是哈希表 在讨论哈希表之前，我们先大概了解下其他数据结构在新增，...
【Java8源码分析】集合框架-HashMap
linxd
05-10 2482
一、HashMap的存储结构总共有两种存储类// 1. 哈希冲突时采用链表法的类，一个哈希桶多于8个元素改为TreeNode static class Node<K,V> implements Map.Entry<K,V> // 2. 哈希冲突时采用红黑树存储的类，一个哈希桶少于8个元素改为Node static final class TreeNode<K,V> extends LinkedHas
【 java 集合】HashMap源码分析
阿牛的博客
01-13 1005
HashMap的底层原理一直以来是面试必问的问题，本节将基于源码分析一下！jdk7版本的HashMap和jdk8的HsahMap底层原理不同，本文主要以jdk8里的HashMap来分析，最后会总结jdk7与jdk8中HashMap的底层原理，用来对比不同！
Java集合框架源码分析：hashMap
玉汝于成
05-29 1294
特性描述是否允许为nullkey和value都可以取值为null是否允许重复key重复会覆盖，value允许重复是否有序无序是否线程安全非线程安全JDK1.8之前HashMap是由数组 + 链表结构组成，数组是HashMap的主体，链表则是主要为了解决哈希冲突（两个对象调用的hashCode方法计算的哈希码值一致导致计算的数组索引值相同）而存在（拉链法：解决冲突）。JDK1.8以后（包含JDK1.8）HashMap是由数组+链表+红黑树组成。
Java集合源码全面分析
09-02
在本文中，我们将全面分析Java集合框架的核心概念和实现细节。 首先，Java集合框架的基础是`Collection`接口，它是所有集合类的根接口，定义了集合的基本操作。`Collection`接口有两个重要的子接口：`List`和`Set`...
HashMap 源码分析
12-22
《HashMap 源码解析——JDK11版本》 HashMap是Java中广泛使用的非同步散列表，其设计和实现是高效且灵活的。在JDK1.8之前，HashMap的底层数据...理解HashMap的源码对于深入学习Java集合框架和数据结构具有重要意义。
java集合类源码分析之Set详解
08-29
Java集合类源码分析之Set详解 Java集合类中的Set Interface是用于存储无序、不可重复元素的集合接口。Set Interface继承自Collection Interface，提供了基本的集合操作，如add、remove、contains等。Set Interface...
深入理解Java之HashMap源码剖析
08-31
深入理解Java中的HashMap源码，有助于我们更好地掌握这个常用数据结构的工作原理。HashMap是Java集合框架的重要组成部分，它实现了Map接口，提供了一种快速查找、插入和删除元素的方式。本文将详细解析HashMap的内部...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 312
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 1103
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 147
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 590
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
深入解析Java集合框架：HashMap到LinkedHashMap
这是一份针对Java集合框架深入学习的指南，特别关注了JDK7版本的源码分析。作者通过一系列的文章，详细讲解了不同集合类的实现原理，旨在帮助读者理解其中的设计思想并掌握如何在实际开发中合理选择和使用集合。 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值