① java集合关系图全景概览
Java集合框架(Java Collections Framework)是Java语言中用于存储、组织和操作数据的核心机制之一。它提供了一套统一的接口、抽象类和具体实现类,用于处理各类数据结构场景。从设计角度看,整个集合体系以Collection和Map为两大根接口,向下派生出List、Set、Queue、Deque等子接口,并进一步由具体实现类(如ArrayList、LinkedList、HashMap、TreeMap、HashSet、LinkedHashSet、TreeSet、ConcurrentHashMap等)完成底层数据结构与行为逻辑的实现。
理解java集合关系图,不仅有助于掌握各集合类的继承结构与接口契约,更是深入理解Java集合性能特征、线程安全性、适用场景及内存占用的关键前提。本图从顶层接口出发,逐层剖析核心子类的底层实现原理、时间复杂度、适用边界及典型错误用法,为开发者构建完整、系统的集合知识体系。
当前主流JDK版本(JDK 8~JDK 21)中,集合框架整体保持高度兼容,但部分实现类在并发安全性、哈希算法优化、内存布局等方面存在细微演进。例如JDK 8中HashMap引入红黑树优化,JDK 1.8之后ConcurrentHashMap取消分段锁(Segment)改用CAS + synchronized,JDK 16中Arrays.asList()返回的List实现类从非公开类改为Arrays$ArrayList,JDK 21中HashMap默认负载因子调整为0.6而非0.75。这些变化均需结合实际版本进行适配性开发。
特别说明:本图以JDK 8为基准,兼顾JDK 11/17主流生产环境,覆盖从Object基类到所有常用集合类的完整关系链,重点标注线程安全边界、扩容机制、哈希冲突处理策略、迭代器Fail-Fast机制等关键设计点,帮助开发者从“知其然”进阶至“知其所以然”。
② Collection体系:List、Set、Queue深度解构
● 根接口:Collection与Iterator
Collection是Java集合体系的顶层接口之一(另一个是Map),定义了集合的基本操作:添加(add)、删除(remove)、查询(contains)、大小(size)、清空(clear)、遍历(iterator)等。所有实现了Collection接口的类都具备这些通用能力,但具体行为因实现类而异。
值得注意的是,Collection本身不提供任何实现,所有方法都由子接口或子类自行实现。其唯一子类契约是:不允许插入重复元素的Set类集合,必须通过equals()与hashCode()共同保证唯一性;而允许重复的List类集合则无此限制。
所有Collection实现类都支持迭代器(Iterator),用于顺序遍历元素。迭代器采用Fail-Fast机制:当集合在迭代过程中被结构性修改(如add/remove),会抛出ConcurrentModificationException异常。该机制虽非线程安全保证,但能及时发现并发修改错误,避免数据不一致。
● List接口:有序可重复序列
List接口继承自Collection,表示有序、可重复的元素序列。其核心特征包括:
- 严格维护插入顺序(insertion order)
- 支持通过索引访问元素(
get(int index)、set(int index, E element)) - 允许插入多个
null元素(ArrayList、LinkedList均支持) - 提供
listIterator()支持双向遍历与元素修改
主流实现类:ArrayList、LinkedList、Vector(已废弃)、CopyOnWriteArrayList(并发安全)
● ArrayList:动态数组实现
底层基于Object[] elementData数组实现,初始容量为10。当容量不足时,扩容为原容量的1.5倍(JDK 8起采用oldCapacity + (oldCapacity >> 1)),并通过Arrays.copyOf()复制数组。扩容操作时间复杂度为O(n),但摊还后单次插入平均为O(1)。
优势:随机访问快(O(1))、内存连续、缓存友好;劣势:中间插入/删除慢(需移动后续元素,O(n));适用场景:频繁读取、尾部追加、少量修改。
● LinkedList:双向链表实现
底层为双向链表结构,每个节点包含前驱(prev)、后继(next)与元素(item)。支持头尾O(1)插入/删除(addFirst、addLast),但随机访问需遍历(O(n))。JDK 1.6起废弃addFirst/addLast,改用offerFirst/offerLast统一Deque接口。
除作为List使用外,LinkedList还实现了Deque接口,可作为双端队列、栈(push/pop)或队列(offer/poll)使用。但因其节点开销大(每个元素需额外存储两个引用),内存效率低于ArrayList。
● Vector:同步数组(已过时)
与ArrayList类似,但所有公共方法均用synchronized修饰,导致高竞争下性能极差。其扩容策略为2倍(capacityIncrement参数可调)。JDK 1.2后已被ArrayList取代,仅在遗留系统中可见。
● Set接口:无序不可重复集合
Set接口继承自Collection,表示无序、不可重复的元素集合。其唯一约束是:任意两个元素e1与e2满足!e1.equals(e2)。判断重复的标准是equals()与hashCode()的组合:
- 若
hashCode()不同 → 直接视为不同元素 - 若
hashCode()相同 → 进一步调用equals()确认
主流实现类:HashSet、LinkedHashSet、TreeSet、CopyOnWriteArraySet、EnumSet(枚举专用)
● HashSet:哈希表实现
底层基于HashMap实现,每个元素作为key存入,value统一为PRESENT(静态常量对象)。因此其性能完全依赖hashCode()与equals()的实现质量。默认初始容量16,负载因子0.75,超过阈值时扩容为2倍并重新哈希(rehash)。
⚠️ 注意:若自定义类作为元素,必须重写hashCode()与equals(),否则无法保证唯一性(如使用默认Object实现,每个对象哈希码不同)。
● LinkedHashSet:哈希+链表实现
继承自HashSet,内部维护一个双向链表记录插入顺序。因此兼具HashSet的高效查找与顺序遍历能力。内存占用略高于HashSet(每个节点多两个引用),但遍历性能更优(无需遍历整个哈希桶)。
● TreeSet:红黑树实现
基于TreeMap实现,底层为自平衡二叉搜索树(红黑树),元素按自然顺序或自定义比较器(Comparator)排序。插入/删除/查找均为O(log n),但有序性使其适用于范围查询(subSet、headSet、tailSet)。
⚠️ 注意:TreeSet要求元素实现Comparable接口或提供非空Comparator,否则抛出ClassCastException。且其equals()与hashCode()被忽略,比较仅依赖compareTo()或compare()返回值。
● Queue与Deque:队列与双端队列
Queue接口定义先进先出(FIFO)队列操作:offer()(插入)、poll()(取出并删除)、peek()(查看但不删除)。JDK 1.5新增Deque接口(Double-ended Queue),支持两端操作:addFirst、addLast、removeFirst、removeLast等。
主流实现类:LinkedList(通用)、ArrayDeque(推荐,基于循环数组)、PriorityQueue(堆实现,无固定顺序)、ConcurrentLinkedQueue(无界并发安全)
● ArrayDeque:高性能双端队列
底层为Object[] elements循环数组,初始容量16。插入时通过位运算(tail = (tail + 1) & (elements.length - 1))计算尾指针,避免取模开销。扩容策略为2倍,并保持循环特性。
相比LinkedList,ArrayDeque无节点对象开销,缓存命中率更高,是实现栈/队列的首选(JDK官方文档明确推荐)。但其不支持null元素(因peek返回null无法区分空队列与null值)。
③ Map体系:键值对映射全解析
● 根接口:Map核心契约
Map接口表示键值对(key-value)的映射关系,不继承Collection。其核心约束:
- 键(key)必须唯一,值(value)可重复
- 至多一个
null键(HashMap支持),值可多个null - 遍历视图为
entrySet()、keySet()、values() - 线程安全需外部同步或使用并发类
主流实现类:HashMap、LinkedHashMap、TreeMap、ConcurrentHashMap、Hashtable(已废弃)、EnumMap(枚举键专用)
● HashMap:JDK 8红黑树优化详解
JDK 8对HashMap进行了重大重构,核心改进点:
- 链表长度≥8且表长≥64时,转为红黑树(避免哈希退化为链表)
- 插入时若桶为空,直接赋值;否则遍历链表/红黑树查找或插入
- 扩容时通过
hash & oldCap == 0判断元素新位置(保持原索引或oldIndex+oldCap) - 移除Entry数组+单向链表结构,改用Node数组+双向链表/红黑树
默认初始容量16,负载因子0.75。当元素数 > capacity × loadFactor时触发扩容。扩容操作涉及重新哈希(rehash),时间复杂度O(n),应尽量避免(可通过预估容量初始化)。
典型错误示例:
Mapmap = new HashMap<>(); // 未重写hashCode()与equals()的自定义Key类 class MyKey { String id; MyKey(String id) { this.id = id; } } map.put(new MyKey("A"), 1); // hashCode()默认不同 → 插入成功 map.put(new MyKey("A"), 2); // 新对象hashCode()仍不同 → 重复插入! System.out.println(map.size()); // 输出2(应为1)
正确做法:重写hashCode()与equals(),确保逻辑一致。
● LinkedHashMap:哈希+链表实现
在HashMap基础上增加双向链表维护访问/插入顺序。通过accessOrder参数控制:
• accessOrder=false(默认):按插入顺序迭代
• accessOrder=true:按最近访问顺序迭代(LRU缓存基础)
实现方式:每个Node节点增加before与after指针,形成双向链表。插入/删除时同步更新链表,遍历时直接沿链表移动。
适用场景:需要保持顺序的缓存、日志记录、状态机等。
● TreeMap:红黑树排序映射
底层为红黑树,键按自然顺序或比较器排序。支持高效范围查询:
• subMap(K fromKey, K toKey):返回[fromKey, toKey)子Map
• headMap(K toKey):返回< toKey子Map
• tailMap(K fromKey):返回≥fromKey子Map
所有操作时间复杂度为O(log n),但常数因子大于HashMap。适用于需要排序输出或范围查询的场景。
⚠️ 注意:TreeMap比较键时仅依赖compareTo()或compare(),与equals()无关。例如:
TreeMapmap = new TreeMap<>(); map.put(new BigDecimal("1.0"), "A"); // hashCode()与equals()被忽略 map.put(new BigDecimal("1.00"), "B"); // compareTo()返回0 → 覆盖! System.out.println(map.size()); // 输出1
● ConcurrentHashMap:并发安全映射
JDK 7 vs JDK 8架构对比:
| 特性 | JDK 7 | JDK 8+ |
|---|---|---|
| 分段锁 | Segment[] + HashEntry[] | 取消Segment,直接用Node[] |
| 锁粒度 | 16把锁(Segment数量) | 桶级锁(synchronized)+ CAS |
| 扩容 | 分段扩容 | 全表扩容 + 帮助迁移 |
| 遍历 | 快照视图(弱一致性) | 基于桶的弱一致性 |
JDK 8实现:
• 使用Node数组存储数据,每个桶可为链表或红黑树
• 插入时若桶为空,用CAS设置;否则用synchronized锁住桶头节点
• 扩容时多个线程协作迁移(每个线程处理一段桶区间)
• 遍历通过Traverser类实现弱一致性视图
关键参数:
• DEFAULT_CAPACITY = 16
• DEFAULT_LOAD_FACTOR = 0.75f
• UNTREEIFY_THRESHOLD = 6(退化阈值)
• TREEIFY_THRESHOLD = 8(转树阈值)
⚠️ 注意:ConcurrentHashMap不允许null键或值(抛出NPE),因get返回null无法区分“不存在”与“值为null”。
④ 核心集合类性能对比表
| 集合类型 | 底层结构 | 有序性 | 线程安全 | 插入O(1) | 查找O(1) | 内存开销 | 适用场景 |
|---|---|---|---|---|---|---|---|
| ArrayList | 动态数组 | 插入顺序 | 否 | 尾部O(1) | 索引O(1) | 低 | 频繁读取、尾部追加 |
| LinkedList | 双向链表 | 插入顺序 | 否 | 头尾O(1) | 遍历O(n) | 高(节点引用) | 频繁中间插入/删除 |
| HashSet | HashMap键 | 无序 | 否 | O(1) | O(1) | 中 | 去重、快速查找 |
| LinkedHashSet | HashMap+链表 | 插入顺序 | 否 | O(1) | O(1) | 高 | 去重+顺序遍历 |
| TreeSet | TreeMap键 | 排序顺序 | 否 | O(log n) | O(log n) | 中 | 排序+范围查询 |
| HashMap | Node数组 | 无序 | 否 | O(1) | O(1) | 中 | 通用键值映射 |
| LinkedHashMap | HashMap+链表 | 插入/访问顺序 | 否 | O(1) | O(1) | 高 | 顺序Map/LRU缓存 |
| TreeMap | 红黑树 | 排序顺序 | 否 | O(log n) | O(log n) | 中 | 排序Map/范围查询 |
| ConcurrentHashMap | Node数组+链表 | 无序 | 是 | O(1) | O(1) | 中 | 高并发键值映射 |
| ArrayDeque | 循环数组 | 插入顺序 | 否 | 头尾O(1) | 遍历O(n) | 低 | 栈/队列/双端队列 |
● 内存占用实测对比(100万条Integer数据)
| 集合类型 | 堆内存(MB) | 对象数 | 节点开销 |
|---|---|---|---|
| ArrayList | 12.8 | 1,000,001 | 仅数组头+元素引用 |
| LinkedList | 48.2 | 4,000,001 | 每个节点含prev/next/item+对象头 |
| HashSet | 28.6 | 1,500,001 | HashMap$Node + value常量 |
| LinkedHashSet | 36.4 | 2,000,001 | HashMap$Node + before/after |
| TreeSet | 32.1 | 2,000,001 | TreeNode(红黑树节点) |
数据来源:JDK 8u292,64位Server VM,-Xmx1G,-XX:+UseG1GC
⑤ 线程安全集合全景图
● 同步包装器(Synchronization Wrappers)
JDK提供静态方法为非线程安全集合添加同步包装:
MapsyncMap = Collections.synchronizedMap(new HashMap<>()); List syncList = Collections.synchronizedList(new ArrayList<>()); Set syncSet = Collections.synchronizedSet(new HashSet<>());
⚠️ 注意:这些包装器仅保证单次操作的原子性,复合操作(如迭代)仍需手动同步:
MapsyncMap = Collections.synchronizedMap(new HashMap<>()); synchronized(syncMap) { for (String key : syncMap.keySet()) { // 必须同步! System.out.println(key + "=" + syncMap.get(key)); } }
● 并发集合类对比
| 集合类 | 接口 | 线程安全机制 | 并发度 | 是否支持null | 弱一致性迭代器 |
|---|---|---|---|---|---|
| Vector | List | 方法级synchronized | 1 | 是 | 否 |
| Hashtable | Map | 方法级synchronized | 1 | 否 | 否 |
| CopyOnWriteArrayList | List | COW(写时复制) | 高写低读 | 是 | 是 |
| CopyOnWriteArraySet | Set | COW + HashSet | 高写低读 | 是 | 是 |
| ConcurrentHashMap | Map | CAS + synchronized | 高 | 否 | 是 |
| ConcurrentLinkedQueue | Queue | CAS无锁 | 高 | 否 | 是 |
| ConcurrentSkipListMap | Map | 跳表 | 高 | 否 | 是 |
● CopyOnWriteArrayList详解
写操作(add/remove)时复制整个底层数组,新数组写入完成后再替换引用。优点是读操作无锁,适合读多写少场景(如监听器列表)。缺点是写时内存峰值翻倍,且写操作慢(O(n))。
适用场景:
• 监听器/观察者列表
• 配置项集合(启动后几乎不变)
• 缓存列表(仅初始化时写入)
⚠️ 注意:其迭代器是快照视图,不反映迭代期间的修改:
CopyOnWriteArrayListlist = new CopyOnWriteArrayList<>(); list.add("A"); Iterator it = list.iterator(); list.add("B"); while(it.hasNext()) { System.out.println(it.next()); // 仅输出"A",不包含"B" }
⑥ 网友们都关心什么?——高频问题TOP10
HashMap vs HashTable:核心差异五维度
- 线程安全:HashTable所有方法synchronized,HashMap非线程安全
- null支持:HashMap允许1个null键、多个null值;HashTable不允许任何null
- 性能:HashTable锁粒度大,高竞争下性能极差;HashMap通过分段锁优化
- 继承:HashTable继承Dictionary(已废弃),HashMap继承AbstractMap
- 默认容量:HashTable=11(质数),HashMap=16(2的幂)
现代开发中,应避免使用HashTable,改用ConcurrentHashMap(并发场景)或HashMap(单线程场景)。
ArrayList vs LinkedList:决策树
是否频繁随机访问?
├─ 是 → ArrayList(O(1)索引访问)
└─ 否
├─ 是否频繁头尾插入?
│ ├─ 是 → ArrayDeque(最优)
│ └─ 否
│ ├─ 是否需要中间插入?
│ │ ├─ 是 → LinkedList(O(1)插入)
│ │ └─ 否 → ArrayList(内存效率高)
│
└─ 是否需要栈/队列功能?
├─ 是 → ArrayDeque(JDK推荐)
└─ 否 → 按上述分支判断
实测数据:100万次操作(JDK 8u292)
| 操作 | ArrayList | LinkedList | ArrayDeque |
|---|---|---|---|
| 尾部追加 | 12ms | 45ms | 8ms |
| 头部插入 | 2800ms | 15ms | 6ms |
| 中间删除 | 1800ms | 20ms | N/A |
equals()与hashCode()契约:Java集合基石
Java规范要求:
若e1.equals(e2)为true,则e1.hashCode()必须等于e2.hashCode()
违反此规则的后果:
• HashSet中可能插入重复元素(因哈希桶不同)
• HashMap中相同键可能对应多个值
• equals()仅比较逻辑相等,hashCode()决定存储位置
正确实现模板:
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return Objects.equals(name, person.name) &&
age == person.age;
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
推荐使用Objects.hash()自动生成,避免手动计算哈希值导致不一致。
ConcurrentHashMap高并发原理:三板斧
- CAS无锁插入:桶为空时用CAS原子设置节点
- 桶级synchronized:非空时锁住桶头节点,非整表锁
- 帮助扩容:多线程协作迁移数据,每个线程处理一段桶区间
示例:插入操作流程
if (tab == null || (n = tab.length) == 0)
tab = initTable(); // CAS初始化
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<>(hash, key, value, null)))
break; // CAS成功 → 无锁插入
}
else {
synchronized(f) { // 桶头节点加锁
// 链表/红黑树插入逻辑
}
}
TreeSet排序机制:compareTo()的绝对权威
TreeSet内部使用TreeMap存储数据,键的比较完全依赖compareTo()或compare()返回值,与equals()无关。
典型陷阱:
TreeSetset = new TreeSet<>(); set.add(new BigDecimal("1.0")); // compareTo返回0 set.add(new BigDecimal("1.00")); // compareTo仍返回0 → 覆盖! System.out.println(set.size()); // 输出1,而非2
解决方案:
- 使用
BigDecimal.valueOf()(避免创建新对象) - 或指定比较器:
Comparator.naturalOrder().thenComparing(BigDecimal::scale)
Fail-Fast机制:快速失败的真相
迭代器通过维护expectedModCount字段与集合的modCount同步。当集合结构性修改(add/remove/clear)时,modCount++,若迭代时发现两者不一致,抛出ConcurrentModificationException。
⚠️ 注意:
• 不是线程安全机制!仅检测单线程中的并发修改
• 非结构性操作(如set())不触发Fail-Fast
• 某些实现(如CopyOnWriteArrayList)无Fail-Fast
安全遍历方式:
// 方案1:同步块(适用于同步集合)
synchronized(list) {
for (String s : list) { ... }
}
// 方案2:使用CopyOnWriteArrayList
CopyOnWriteArrayList list = new CopyOnWriteArrayList<>();
// 方案3:复制后遍历(适合小数据量)
List copy = new ArrayList<>(list);
for (String s : copy) { ... }
ArrayDeque vs Stack:为什么Stack被废弃?
Stack继承自Vector,所有方法synchronized,导致性能极差。且其API设计缺陷:
- 继承Vector → 暴露了非栈方法(如add、remove)
- push/pop混合使用 → 容易出错
- 扩容策略为2倍 → 内存浪费
JDK官方推荐:
• 单线程栈 → ArrayDeque(push/pop)
• 并发栈 → ConcurrentLinkedDeque
Stack使用示例(不推荐):
Stackstack = new Stack<>(); stack.push("A"); stack.push("B"); System.out.println(stack.pop()); // 输出"B" System.out.println(stack.size()); // 输出1 // stack.add("C"); // 违反栈原则!
ArrayDeque正确用法:
Dequestack = new ArrayDeque<>(); stack.push("A"); stack.push("B"); System.out.println(stack.pop()); // 输出"B"
避免HashMap扩容抖动:预估容量的艺术
扩容触发条件:size > capacity × loadFactor
预估容量公式:expectedSize / 0.75f + 1,并取2的幂
示例:预计存1000条数据
// 错误做法 Mapmap = new HashMap<>(); // 默认16容量 for (int i=0; i<1000; i++) { map.put("key"+i, i); // 触发多次扩容(16→32→64→128→256→512→1024) } // 正确做法 int expectedSize = 1000; int capacity = (int)Math.ceil(expectedSize / 0.75f) + 1; int realCapacity = 1; while (realCapacity < capacity) realCapacity <<= 1; Map map = new HashMap<>(realCapacity); // 初始容量2048 for (int i=0; i<1000; i++) { map.put("key"+i, i); // 无需扩容,性能提升30%+
TreeMap的equals()为何被忽略?
TreeMap的键比较完全依赖compareTo()或compare(),其键相等性定义为:
e1.equals(e2) 当且仅当 compare(e1, e2) == 0
因此,即使两个键逻辑上不同(equals返回false),只要比较结果为0,就视为同一键。
典型案例:
TreeMapmap = new TreeMap<>(); map.put(BigDecimal.ONE, "A"); // compareTo("1.0")返回0 map.put(BigDecimal.valueOf(1.00), "B"); System.out.println(map.size()); // 输出1
解决方案:
- 使用
BigDecimal.valueOf()避免重复对象 - 或指定比较器:
Comparator.naturalOrder().thenComparing(BigDecimal::scale)
线程安全集合选择决策树
是否高并发?
├─ 否 → ArrayList/HashMap/HashSet(单线程最优)
└─ 是
├─ 是否需要Map?
│ ├─ 是 → ConcurrentHashMap(高并发Map首选)
│ └─ 否
│ ├─ 是否读多写少?
│ │ ├─ 是 → CopyOnWriteArrayList/CopyOnWriteArraySet
│ │ └─ 否
│ │ ├─ 是否队列?
│ │ │ ├─ 是 → ConcurrentLinkedQueue
│ │ │ └─ 否
│ │ │ ├─ 是否需要排序?
│ │ │ │ ├─ 是 → ConcurrentSkipListMap
│ │ │ │ └─ 否 → ArrayBlockingQueue(有界)
⑦ 高频面试题深度解析(附答案)
Q1:HashMap的扩容机制及JDK 8优化点?
答案要点:
• 默认容量16,负载因子0.75,触发条件:size > capacity × 0.75
• 扩容为2倍,通过hash & oldCap == 0判断新位置(原索引或oldIndex+oldCap)
• JDK 8优化:
- 链表长度≥8且表长≥64时转红黑树
- 扩容时多线程协作迁移(帮助扩容)
- 移除Entry数组,改用Node数组+双向链表
Q2:为什么重写equals必须重写hashCode?
答案要点:
• Java规范要求:相等对象必须有相同哈希码
• HashSet/HashMap依赖hashCode()定位桶,再用equals()确认相等
• 违反契约会导致重复元素插入、查找失败等异常行为
• 推荐使用Objects.hash()生成哈希码
Q3:ConcurrentHashMap在JDK 7与8的差异?
答案要点:
• JDK 7:Segment分段锁 + HashEntry数组
• JDK 8:取消Segment,直接用Node数组 + CAS + synchronized
• 锁粒度:JDK 7为Segment级(16锁),JDK 8为桶级(可并行)
• 扩容:JDK 7分段扩容,JDK 8全表扩容+帮助迁移
• 遍历:JDK 8采用Traverser实现弱一致性
Q4:ArrayList与LinkedList内存占用对比?
答案要点:
• ArrayList:仅存储元素引用+数组头,内存连续
• LinkedList:每个元素需额外存储prev/next引用(2×8字节/节点)
• 实测100万Integer:ArrayList≈12.8MB,LinkedList≈48.2MB
• ArrayList内存效率更高,LinkedList适合频繁中间插入
Q5:TreeSet为何要求元素可比较?
答案要点:
• TreeSet基于TreeMap实现,键必须实现Comparable或提供Comparator
• 比较仅依赖compareTo(),与equals()无关
• 违反规则会导致ClassCastException或逻辑错误
• 示例:BigDecimal("1.0")与("1.00")compareTo()返回0 → 视为同一元素
Q6:Fail-Fast机制如何工作?
答案要点:
• 迭代器维护expectedModCount,集合维护modCount
• 结构性修改时modCount++,迭代时检查两者是否相等
• 不相等则抛出ConcurrentModificationException
• 仅检测单线程修改,非线程安全保证
• 安全遍历方式:同步块/CopyOnWriteArrayList/复制遍历
⑧ 实战最佳实践:从错误到优雅
错误案例1:未重写hashCode导致Set重复
问题代码:
class User {
String name;
User(String name) { this.name = name; }
}
Set set = new HashSet<>();
set.add(new User("Alice"));
set.add(new User("Alice")); // 重复添加!
System.out.println(set.size()); // 输出2
修复方案:
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(name);
}
错误案例2:HashMap扩容抖动
问题代码:
Mapmap = new HashMap<>(); for (int i=0; i<100000; i++) { map.put("key"+i, i); // 触发约17次扩容 }
修复方案:
int expectedSize = 100000; int capacity = (int)Math.ceil(expectedSize / 0.75f) + 1; int realCapacity = 1; while (realCapacity < capacity) realCapacity <<= 1; Mapmap = new HashMap<>(realCapacity); // 初始容量131072
错误案例3:Stack被误用为通用列表
问题代码:
Stackstack = new Stack<>(); stack.add(1); // 违反栈原则! stack.remove(0); // 删除非栈顶元素
修复方案:
Dequestack = new ArrayDeque<>(); stack.push(1); // 仅允许栈操作 stack.push(2); System.out.println(stack.pop()); // 输出2
错误案例4:TreeSet的compareTo陷阱
问题代码:
TreeSetset = new TreeSet<>(); set.add(new BigDecimal("1.0")); set.add(new BigDecimal("1.00")); // compareTo返回0 → 覆盖! System.out.println(set.size()); // 输出1
修复方案:
// 方案1:使用valueOf set.add(BigDecimal.valueOf(1.0)); set.add(BigDecimal.valueOf(1.00)); // 相同对象 → 覆盖 // 方案2:指定比较器 TreeSetset = new TreeSet<>(Comparator.naturalOrder().thenComparing(BigDecimal::scale)); set.add(new BigDecimal("1.0")); set.add(new BigDecimal("1.00")); // scale不同 → 不覆盖! System.out.println(set.size()); // 输出2
错误案例5:未同步遍历同步集合
问题代码:
MapsyncMap = Collections.synchronizedMap(new HashMap<>()); syncMap.put("A", 1); // 遍历时未同步! for (String key : syncMap.keySet()) { // 可能抛出CME System.out.println(syncMap.get(key)); }
修复方案:
synchronized(syncMap) {
for (String key : syncMap.keySet()) {
System.out.println(syncMap.get(key));
}
}