[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"$f1b300lqgtfmoj":3,"$f250wz8h39yydc":8,"$f3e13fn86h0z0l":29,"$f1tmzc20p7l0cb":37,"$f2qqcwruog50js":72,"toc-989343609-5-5":76},{"description":4,"domain":5,"id":6,"keywords":4,"title":7},"","api.kongjs.com",1,"默认",[9,20,24],{"children":10,"icon":4,"id":11,"linkType":12,"linkUrl":13,"parentId":14,"sort":15,"status":16,"target":17,"title":18,"visible":19},null,"447369447469600768","URL","\u002F","0",0,"1","_self","首页",true,{"children":10,"icon":4,"id":21,"linkType":12,"linkUrl":22,"parentId":14,"sort":15,"status":16,"target":17,"title":23,"visible":19},"447369693859794944","\u002Fnotes","笔记",{"children":10,"icon":4,"id":25,"linkType":26,"linkUrl":27,"parentId":14,"sort":15,"status":16,"target":17,"title":28,"visible":19},"447369977960976384","PAGE","\u002Fabout","关于我",{"category":30,"categoryId":31,"cover":10,"description":4,"fileId":10,"id":34,"publishAt":10,"tags":35,"title":36},{"articleCount":10,"children":10,"cover":10,"description":4,"fileId":10,"icon":4,"id":31,"parentId":14,"slug":32,"sort":15,"title":33},"453164732518506496","back-end","后端","453165633773772800",[],"Java面试核心知识",[38,41,44,48,52,56,60,64,68],{"children":10,"description":4,"id":39,"noteId":34,"parentId":14,"sort":15,"status":16,"title":40},"453165775620939776","Java基础核心全集（数据类型、拆箱装箱、克隆、对象结构、字符串、包装类、序列化）",{"children":10,"description":4,"id":42,"noteId":34,"parentId":14,"sort":6,"status":16,"title":43},"453166088570544128","JVM原理（JDK8~25）内存结构、分代模型、GC算法、垃圾收集器、元空间、双亲委派机制",{"children":10,"description":4,"id":45,"noteId":34,"parentId":14,"sort":46,"status":16,"title":47},"453166295265845248",2,"Java8至25 对象创建全过程及各版本底层演进差异",{"children":10,"description":4,"id":49,"noteId":34,"parentId":14,"sort":50,"status":16,"title":51},"453166545573519360",3,"Java集合全套原理（List+Map底层、扩容机制、线程安全集合对比）",{"children":10,"description":4,"id":53,"noteId":34,"parentId":14,"sort":54,"status":16,"title":55},"453166809651093504",4,"Java线程原理、六大状态流转、线程结束判断、安全中断、核心方法区别",{"children":10,"description":4,"id":57,"noteId":34,"parentId":14,"sort":58,"status":16,"title":59},"453167023724175360",5,"Java线程池原理、使用规范、常用并发异步工具类",{"children":10,"description":4,"id":61,"noteId":34,"parentId":14,"sort":62,"status":16,"title":63},"453167209447956480",6,"Java 虚拟线程与平台线程：原理、区别与实战使用",{"children":10,"description":4,"id":65,"noteId":34,"parentId":14,"sort":66,"status":16,"title":67},"453167452423987200",7,"CAS与AQS 底层原理、核心流程、面试最全详解",{"children":10,"description":4,"id":69,"noteId":34,"parentId":14,"sort":70,"status":16,"title":71},"453168570885480448",8,"线上服务器CPU飙升 Java代码 完整定位排查流程",{"content":73,"contentType":74,"description":4,"title":51,"wordCount":75},"# Java集合全套原理（List\\+Map底层、扩容机制、线程安全集合对比）\n\n本文一次性讲透 **ArrayList、LinkedList、HashMap、LinkedHashMap、HashTable、ConcurrentHashMap** 底层结构、核心原理、扩容机制、线程安全、优缺点、场景对比，是Java面试必考核心全集，逻辑闭环、无废话、可直接背诵。\n\n## 一、集合整体分类\n\n- **List（有序可重复）**：ArrayList、LinkedList、Vector\n\n- **Map（键值对、key唯一）**：HashMap、LinkedHashMap、HashTable、ConcurrentHashMap\n\n---\n\n## 二、List 系列底层原理 \\& 扩容机制\n\n### 1\\. ArrayList（非线程安全）\n\n#### 底层结构\n\n**Object\\[\\] 动态数组**，基于连续内存存储，支持随机访问。\n\n#### 初始化机制（JDK1\\.8）\n\n- new ArrayList\\(\\)：默认是空数组 **DEFAULTCAPACITY\\_EMPTY\\_ELEMENTDATA**，**懒加载**，不占用内存\n\n- 第一次 add 才初始化容量为 **默认容量10**\n\n- new ArrayList\\(100\\)：直接初始化指定容量数组\n\n#### 扩容原理（核心）\n\n- **扩容时机**：元素个数 size \\>= 数组容量，触发扩容\n\n- **扩容比例**：原容量 \\\u003C\\\u003C 1\\.5倍（原容量 \\+ 原容量\u002F2）\n\n- **扩容流程**：新建更大数组 → **Arrays\\.copyOf 拷贝全部元素** → 替换数组引用\n\n- **最大容量**：Integer\\.MAX\\_VALUE \\- 8\n\n#### 优缺点\n\n- 优点：**查询快（随机访问O\\(1\\)）**\n\n- 缺点：增删末尾快、中间增删慢（需要移动元素）、扩容有拷贝开销、非线程安全\n\n### 2\\. LinkedList（非线程安全）\n\n#### 底层结构\n\n**双向链表**（JDK1\\.6之前是双向循环链表，1\\.7\\+取消循环）\n\n每个节点：prev 前驱指针 \\+ next 后继指针 \\+ data数据\n\n#### 核心特性\n\n- **无数组、无扩容**，按需创建节点\n\n- 首尾增删极快 O\\(1\\)\n\n- 随机查询慢 O\\(n\\)，必须从头遍历\n\n#### 优缺点\n\n- 优点：**任意位置增删效率高**，无内存浪费\n\n- 缺点：查询遍历慢，不支持随机访问\n\n### 3\\. Vector（古老、线程安全）\n\n- 底层也是 Object 数组\n\n- **默认扩容2倍**（比ArrayList更浪费内存）\n\n- 所有方法加 **synchronized**，锁粒度极大，性能极差\n\n- 基本废弃，生产不用\n\n### 4\\. ArrayList vs LinkedList 终极对比\n\n- **查询多、改多、少增删** → ArrayList\n\n- **频繁中间\u002F首尾增删** → LinkedList\n\n---\n\n## 三、Map 系列底层原理 \\& 扩容机制（重点）\n\n### 1\\. HashMap 底层原理（JDK1\\.8）\n\n#### 底层结构\n\n**数组 \\+ 链表 \\+ 红黑树** 三合一结构\n\n- 数组：哈希桶，存放链表\u002F树根节点\n\n- 链表：解决哈希冲突，链地址法\n\n- 红黑树：链表过长优化查询效率\n\n#### 核心阈值（必考）\n\n- **默认初始容量**：16\n\n- **负载因子**：0\\.75\n\n- **扩容阈值**：容量 \\* 0\\.75（16\\*0\\.75=12）\n\n- **树化阈值**：链表长度 \\>= 8 且 数组容量 \\>= 64 → 转红黑树\n\n- **退化阈值**：树节点数量 \\\u003C= 6 → 退化为链表\n\n#### 扩容原理\n\n- **扩容时机**：元素数量 \\>= 扩容阈值\n\n- **扩容倍数**：固定 **2倍扩容**（保证容量永远是2的幂次）\n\n- **重哈希优化**：JDK1\\.8 无需重新计算hash值，通过 **hash \\& 新容量高位** 判断节点迁移位置，要么原下标、要么原下标\\+旧容量\n\n- 大大减少扩容开销\n\n#### HashMap 为什么容量必须是2的幂次？\n\n为了用 **hash \\& \\(len\\-1\\)** 代替取模运算，效率更高，同时保证哈希分布均匀。\n\n#### HashMap 为什么线程不安全？\n\n- 多线程put导致数据覆盖\n\n- JDK1\\.7 多线程扩容会出现 **循环链表、死循环CPU100%**\n\n- JDK1\\.8 修复死循环，但仍存在数据覆盖、丢失数据问题\n\n### 2\\. LinkedHashMap\n\n- 继承 HashMap，底层结构一致\n\n- 额外维护一条 **双向链表**，保证**插入有序\u002F访问有序**\n\n- 可实现 **LRU 缓存淘汰**（重写removeEldestEntry方法）\n\n### 3\\. HashTable（废弃）\n\n- 线程安全，所有方法加 synchronized\n\n- **初始容量11**，扩容 **2倍\\+1**\n\n- **不允许null键、null值**\n\n- 效率极低，完全被 ConcurrentHashMap 替代\n\n---\n\n## 四、线程安全集合 完整对比（面试核心）\n\n### 1\\. 非线程安全集合（常用）\n\n- ArrayList、LinkedList\n\n- HashMap、LinkedHashMap\n\n### 2\\. 线程安全集合分类\n\n#### （1）Vector \u002F HashTable（低效、废弃）\n\n全局方法锁，锁粒度太大，并发性能极差\n\n#### （2）Collections\\.synchronized 包装集合\n\n通过同步代码块加锁，**全局锁**，所有线程竞争同一把锁，并发弱，适合低并发场景\n\n#### （3）JUC高性能线程安全集合（生产推荐）\n\n- **CopyOnWriteArrayList**：ArrayList 线程安全版\n\n- **ConcurrentHashMap**：HashMap 线程安全版\n\n- **CopyOnWriteArraySet**：Set 线程安全版\n\n### 3\\. CopyOnWriteArrayList 原理\n\n#### 核心机制：**写时复制**\n\n- **读不加锁**：读原数组，并发极高\n\n- **写加锁（ReentrantLock）**：写入时复制新数组，修改新数组，最后替换引用\n\n- 弱一致性：迭代器遍历的是旧数组快照，不保证实时最新数据\n\n#### 适用场景\n\n**读多写少**（配置、白名单、常量列表），写多场景会频繁数组拷贝，性能爆炸\n\n### 4\\. ConcurrentHashMap 原理（JDK1\\.8）\n\n#### 核心优化：**CAS \\+ synchronized 细粒度锁**\n\n- 不再分段锁，锁定 **单个桶的头节点**，锁粒度极小\n\n- 无冲突 CAS 写入\n\n- 冲突后加 synchronized 锁桶\n\n- 支持高并发读写，吞吐量极高\n\n#### 特性\n\n- key\u002Fvalue 均**不允许null**\n\n- 扩容、树化、退化逻辑与HashMap基本一致\n\n- 多线程协助扩容，进一步提升并发性能\n\n---\n\n## 五、高频面试对比总结（必背）\n\n### 1\\. ArrayList vs LinkedList\n\n- ArrayList：数组、查询快、中间增删慢、1\\.5倍扩容、有内存开销\n\n- LinkedList：双向链表、无扩容、增删快、查询慢\n\n### 2\\. HashMap vs HashTable vs ConcurrentHashMap\n\n- HashMap：非线程安全、2的幂次容量、1\\.8数组链表红黑树、允许null\n\n- HashTable：全局sync、初始11、扩容2倍\\+1、不允许null、废弃\n\n- ConcurrentHashMap：CAS\\+桶锁、高并发、不允许null、生产首选\n\n### 3\\. 线程安全集合选型口诀\n\n- 读多写少 List → CopyOnWriteArrayList\n\n- 读写并发 Map → ConcurrentHashMap\n\n- 绝对禁止：Vector、HashTable\n\n## 六、扩容机制终极汇总\n\n- **ArrayList**：1\\.5倍扩容\n\n- **Vector**：2倍扩容\n\n- **HashMap\u002FConcurrentHashMap**：2倍扩容、保持2的幂次\n\n- **HashTable**：2倍\\+1扩容\n\n- **LinkedList**：无扩容机制","markdown",3684,{"frontmatter":77,"meta":78,"nodes":205},{},{"title":51,"description":79,"toc":80},"本文一次性讲透 ArrayList、LinkedList、HashMap、LinkedHashMap、HashTable、ConcurrentHashMap 底层结构、核心原理、扩容机制、线程安全、优缺点、场景对比，是Java面试必考核心全集，逻辑闭环、无废话、可直接背诵。",{"title":4,"searchDepth":58,"depth":58,"links":81},[82,84,121,149,189,202],{"id":4,"depth":46,"text":83},"一、集合整体分类",{"id":85,"depth":46,"text":86,"children":87},"list","二、List 系列底层原理 & 扩容机制",[88,104,115,118],{"id":89,"depth":50,"text":90,"children":91},"list-_1-arraylist","1. ArrayList（非线程安全）",[92,95,98,101],{"id":93,"depth":54,"text":94},"list-_1-arraylist-","底层结构",{"id":96,"depth":54,"text":97},"list-_1-arraylist-jdk18","初始化机制（JDK1.8）",{"id":99,"depth":54,"text":100},"list-_1-arraylist--1","扩容原理（核心）",{"id":102,"depth":54,"text":103},"list-_1-arraylist--2","优缺点",{"id":105,"depth":50,"text":106,"children":107},"list-_2-linkedlist","2. LinkedList（非线程安全）",[108,110,113],{"id":109,"depth":54,"text":94},"list-_2-linkedlist-",{"id":111,"depth":54,"text":112},"list-_2-linkedlist--1","核心特性",{"id":114,"depth":54,"text":103},"list-_2-linkedlist--2",{"id":116,"depth":50,"text":117},"list-_3-vector","3. Vector（古老、线程安全）",{"id":119,"depth":50,"text":120},"list-_4-arraylist-vs-linkedlist","4. ArrayList vs LinkedList 终极对比",{"id":122,"depth":46,"text":123,"children":124},"map","三、Map 系列底层原理 & 扩容机制（重点）",[125,143,146],{"id":126,"depth":50,"text":127,"children":128},"map-_1-hashmap-jdk18","1. HashMap 底层原理（JDK1.8）",[129,131,134,137,140],{"id":130,"depth":54,"text":94},"map-_1-hashmap-jdk18-",{"id":132,"depth":54,"text":133},"map-_1-hashmap-jdk18--1","核心阈值（必考）",{"id":135,"depth":54,"text":136},"map-_1-hashmap-jdk18--2","扩容原理",{"id":138,"depth":54,"text":139},"map-_1-hashmap-jdk18-hashmap-2","HashMap 为什么容量必须是2的幂次？",{"id":141,"depth":54,"text":142},"map-_1-hashmap-jdk18-hashmap","HashMap 为什么线程不安全？",{"id":144,"depth":50,"text":145},"map-_2-linkedhashmap","2. LinkedHashMap",{"id":147,"depth":50,"text":148},"map-_3-hashtable","3. HashTable（废弃）",{"id":150,"depth":46,"text":151,"children":152},"-1","四、线程安全集合 完整对比（面试核心）",[153,156,169,179],{"id":154,"depth":50,"text":155},"-_1","1. 非线程安全集合（常用）",{"id":157,"depth":50,"text":158,"children":159},"-_2","2. 线程安全集合分类",[160,163,166],{"id":161,"depth":54,"text":162},"-_2-_1vector-hashtable","（1）Vector \u002F HashTable（低效、废弃）",{"id":164,"depth":54,"text":165},"-_2-_2collectionssynchronized","（2）Collections.synchronized 包装集合",{"id":167,"depth":54,"text":168},"-_2-_3juc","（3）JUC高性能线程安全集合（生产推荐）",{"id":170,"depth":50,"text":171,"children":172},"-_3-copyonwritearraylist","3. CopyOnWriteArrayList 原理",[173,176],{"id":174,"depth":54,"text":175},"-_3-copyonwritearraylist-","核心机制：写时复制",{"id":177,"depth":54,"text":178},"-_3-copyonwritearraylist--1","适用场景",{"id":180,"depth":50,"text":181,"children":182},"-_4-concurrenthashmap-jdk18","4. ConcurrentHashMap 原理（JDK1.8）",[183,186],{"id":184,"depth":54,"text":185},"-_4-concurrenthashmap-jdk18-cas-synchronized","核心优化：CAS + synchronized 细粒度锁",{"id":187,"depth":54,"text":188},"-_4-concurrenthashmap-jdk18-","特性",{"id":190,"depth":46,"text":191,"children":192},"-2","五、高频面试对比总结（必背）",[193,196,199],{"id":194,"depth":50,"text":195},"-_1-arraylist-vs-linkedlist","1. ArrayList vs LinkedList",{"id":197,"depth":50,"text":198},"-_2-hashmap-vs-hashtable-vs-concurrenthashmap","2. HashMap vs HashTable vs ConcurrentHashMap",{"id":200,"depth":50,"text":201},"-_3","3. 线程安全集合选型口诀",{"id":203,"depth":46,"text":204},"-3","六、扩容机制终极汇总",[206,210,219,222,238,241,243,246,249,255,257,279,281,311,313,324,326,328,334,337,339,353,355,366,368,389,391,405,407,409,411,413,419,430,432,464,466,496,498,505,507,521,523,544,546,568,570,572,574,582,584,586,589,591,598,600,620,622,628,645,647,653,655,661,679,681,695,697,699,701,709,711,722,724,735,737],[207,208,51],"h1",{"id":209},"javalistmap",[211,212,213,214,218],"p",{},"本文一次性讲透 ",[215,216,217],"strong",{},"ArrayList、LinkedList、HashMap、LinkedHashMap、HashTable、ConcurrentHashMap"," 底层结构、核心原理、扩容机制、线程安全、优缺点、场景对比，是Java面试必考核心全集，逻辑闭环、无废话、可直接背诵。",[220,221,83],"h2",{"id":4},[223,224,225,232],"ul",{},[226,227,228,231],"li",{},[215,229,230],{},"List（有序可重复）","：ArrayList、LinkedList、Vector",[226,233,234,237],{},[215,235,236],{},"Map（键值对、key唯一）","：HashMap、LinkedHashMap、HashTable、ConcurrentHashMap",[239,240],"hr",{},[220,242,86],{"id":85},[244,245,90],"h3",{"id":89},[247,248,94],"h4",{"id":93},[211,250,251,254],{},[215,252,253],{},"Object[] 动态数组","，基于连续内存存储，支持随机访问。",[247,256,97],{"id":96},[223,258,259,270,276],{},[226,260,261,262,265,266,269],{},"new ArrayList()：默认是空数组 ",[215,263,264],{},"DEFAULTCAPACITY_EMPTY_ELEMENTDATA","，",[215,267,268],{},"懒加载","，不占用内存",[226,271,272,273],{},"第一次 add 才初始化容量为 ",[215,274,275],{},"默认容量10",[226,277,278],{},"new ArrayList(100)：直接初始化指定容量数组",[247,280,100],{"id":99},[223,282,283,289,295,305],{},[226,284,285,288],{},[215,286,287],{},"扩容时机","：元素个数 size >= 数组容量，触发扩容",[226,290,291,294],{},[215,292,293],{},"扩容比例","：原容量 \u003C\u003C 1.5倍（原容量 + 原容量\u002F2）",[226,296,297,300,301,304],{},[215,298,299],{},"扩容流程","：新建更大数组 → ",[215,302,303],{},"Arrays.copyOf 拷贝全部元素"," → 替换数组引用",[226,306,307,310],{},[215,308,309],{},"最大容量","：Integer.MAX_VALUE - 8",[247,312,103],{"id":102},[223,314,315,321],{},[226,316,317,318],{},"优点：",[215,319,320],{},"查询快（随机访问O(1)）",[226,322,323],{},"缺点：增删末尾快、中间增删慢（需要移动元素）、扩容有拷贝开销、非线程安全",[244,325,106],{"id":105},[247,327,94],{"id":109},[211,329,330,333],{},[215,331,332],{},"双向链表","（JDK1.6之前是双向循环链表，1.7+取消循环）",[211,335,336],{},"每个节点：prev 前驱指针 + next 后继指针 + data数据",[247,338,112],{"id":111},[223,340,341,347,350],{},[226,342,343,346],{},[215,344,345],{},"无数组、无扩容","，按需创建节点",[226,348,349],{},"首尾增删极快 O(1)",[226,351,352],{},"随机查询慢 O(n)，必须从头遍历",[247,354,103],{"id":114},[223,356,357,363],{},[226,358,317,359,362],{},[215,360,361],{},"任意位置增删效率高","，无内存浪费",[226,364,365],{},"缺点：查询遍历慢，不支持随机访问",[244,367,117],{"id":116},[223,369,370,373,379,386],{},[226,371,372],{},"底层也是 Object 数组",[226,374,375,378],{},[215,376,377],{},"默认扩容2倍","（比ArrayList更浪费内存）",[226,380,381,382,385],{},"所有方法加 ",[215,383,384],{},"synchronized","，锁粒度极大，性能极差",[226,387,388],{},"基本废弃，生产不用",[244,390,120],{"id":119},[223,392,393,399],{},[226,394,395,398],{},[215,396,397],{},"查询多、改多、少增删"," → ArrayList",[226,400,401,404],{},[215,402,403],{},"频繁中间\u002F首尾增删"," → LinkedList",[239,406],{},[220,408,123],{"id":122},[244,410,127],{"id":126},[247,412,94],{"id":130},[211,414,415,418],{},[215,416,417],{},"数组 + 链表 + 红黑树"," 三合一结构",[223,420,421,424,427],{},[226,422,423],{},"数组：哈希桶，存放链表\u002F树根节点",[226,425,426],{},"链表：解决哈希冲突，链地址法",[226,428,429],{},"红黑树：链表过长优化查询效率",[247,431,133],{"id":132},[223,433,434,440,446,452,458],{},[226,435,436,439],{},[215,437,438],{},"默认初始容量","：16",[226,441,442,445],{},[215,443,444],{},"负载因子","：0.75",[226,447,448,451],{},[215,449,450],{},"扩容阈值","：容量 * 0.75（16*0.75=12）",[226,453,454,457],{},[215,455,456],{},"树化阈值","：链表长度 >= 8 且 数组容量 >= 64 → 转红黑树",[226,459,460,463],{},[215,461,462],{},"退化阈值","：树节点数量 \u003C= 6 → 退化为链表",[247,465,136],{"id":135},[223,467,468,473,483,493],{},[226,469,470,472],{},[215,471,287],{},"：元素数量 >= 扩容阈值",[226,474,475,478,479,482],{},[215,476,477],{},"扩容倍数","：固定 ",[215,480,481],{},"2倍扩容","（保证容量永远是2的幂次）",[226,484,485,488,489,492],{},[215,486,487],{},"重哈希优化","：JDK1.8 无需重新计算hash值，通过 ",[215,490,491],{},"hash & 新容量高位"," 判断节点迁移位置，要么原下标、要么原下标+旧容量",[226,494,495],{},"大大减少扩容开销",[247,497,139],{"id":138},[211,499,500,501,504],{},"为了用 ",[215,502,503],{},"hash & (len-1)"," 代替取模运算，效率更高，同时保证哈希分布均匀。",[247,506,142],{"id":141},[223,508,509,512,518],{},[226,510,511],{},"多线程put导致数据覆盖",[226,513,514,515],{},"JDK1.7 多线程扩容会出现 ",[215,516,517],{},"循环链表、死循环CPU100%",[226,519,520],{},"JDK1.8 修复死循环，但仍存在数据覆盖、丢失数据问题",[244,522,145],{"id":144},[223,524,525,528,537],{},[226,526,527],{},"继承 HashMap，底层结构一致",[226,529,530,531,533,534],{},"额外维护一条 ",[215,532,332],{},"，保证",[215,535,536],{},"插入有序\u002F访问有序",[226,538,539,540,543],{},"可实现 ",[215,541,542],{},"LRU 缓存淘汰","（重写removeEldestEntry方法）",[244,545,148],{"id":147},[223,547,548,551,560,565],{},[226,549,550],{},"线程安全，所有方法加 synchronized",[226,552,553,556,557],{},[215,554,555],{},"初始容量11","，扩容 ",[215,558,559],{},"2倍+1",[226,561,562],{},[215,563,564],{},"不允许null键、null值",[226,566,567],{},"效率极低，完全被 ConcurrentHashMap 替代",[239,569],{},[220,571,151],{"id":150},[244,573,155],{"id":154},[223,575,576,579],{},[226,577,578],{},"ArrayList、LinkedList",[226,580,581],{},"HashMap、LinkedHashMap",[244,583,158],{"id":157},[247,585,162],{"id":161},[211,587,588],{},"全局方法锁，锁粒度太大，并发性能极差",[247,590,165],{"id":164},[211,592,593,594,597],{},"通过同步代码块加锁，",[215,595,596],{},"全局锁","，所有线程竞争同一把锁，并发弱，适合低并发场景",[247,599,168],{"id":167},[223,601,602,608,614],{},[226,603,604,607],{},[215,605,606],{},"CopyOnWriteArrayList","：ArrayList 线程安全版",[226,609,610,613],{},[215,611,612],{},"ConcurrentHashMap","：HashMap 线程安全版",[226,615,616,619],{},[215,617,618],{},"CopyOnWriteArraySet","：Set 线程安全版",[244,621,171],{"id":170},[247,623,624,625],{"id":174},"核心机制：",[215,626,627],{},"写时复制",[223,629,630,636,642],{},[226,631,632,635],{},[215,633,634],{},"读不加锁","：读原数组，并发极高",[226,637,638,641],{},[215,639,640],{},"写加锁（ReentrantLock）","：写入时复制新数组，修改新数组，最后替换引用",[226,643,644],{},"弱一致性：迭代器遍历的是旧数组快照，不保证实时最新数据",[247,646,178],{"id":177},[211,648,649,652],{},[215,650,651],{},"读多写少","（配置、白名单、常量列表），写多场景会频繁数组拷贝，性能爆炸",[244,654,181],{"id":180},[247,656,657,658],{"id":184},"核心优化：",[215,659,660],{},"CAS + synchronized 细粒度锁",[223,662,663,670,673,676],{},[226,664,665,666,669],{},"不再分段锁，锁定 ",[215,667,668],{},"单个桶的头节点","，锁粒度极小",[226,671,672],{},"无冲突 CAS 写入",[226,674,675],{},"冲突后加 synchronized 锁桶",[226,677,678],{},"支持高并发读写，吞吐量极高",[247,680,188],{"id":187},[223,682,683,689,692],{},[226,684,685,686],{},"key\u002Fvalue 均",[215,687,688],{},"不允许null",[226,690,691],{},"扩容、树化、退化逻辑与HashMap基本一致",[226,693,694],{},"多线程协助扩容，进一步提升并发性能",[239,696],{},[220,698,191],{"id":190},[244,700,195],{"id":194},[223,702,703,706],{},[226,704,705],{},"ArrayList：数组、查询快、中间增删慢、1.5倍扩容、有内存开销",[226,707,708],{},"LinkedList：双向链表、无扩容、增删快、查询慢",[244,710,198],{"id":197},[223,712,713,716,719],{},[226,714,715],{},"HashMap：非线程安全、2的幂次容量、1.8数组链表红黑树、允许null",[226,717,718],{},"HashTable：全局sync、初始11、扩容2倍+1、不允许null、废弃",[226,720,721],{},"ConcurrentHashMap：CAS+桶锁、高并发、不允许null、生产首选",[244,723,201],{"id":200},[223,725,726,729,732],{},[226,727,728],{},"读多写少 List → CopyOnWriteArrayList",[226,730,731],{},"读写并发 Map → ConcurrentHashMap",[226,733,734],{},"绝对禁止：Vector、HashTable",[220,736,204],{"id":203},[223,738,739,745,751,757,763],{},[226,740,741,744],{},[215,742,743],{},"ArrayList","：1.5倍扩容",[226,746,747,750],{},[215,748,749],{},"Vector","：2倍扩容",[226,752,753,756],{},[215,754,755],{},"HashMap\u002FConcurrentHashMap","：2倍扩容、保持2的幂次",[226,758,759,762],{},[215,760,761],{},"HashTable","：2倍+1扩容",[226,764,765,768],{},[215,766,767],{},"LinkedList","：无扩容机制"]