Java 集合框架总览

1. 为什么需要集合

数组的局限性：长度固定，无法动态扩容；功能单一，无法直接支持排序、去重、键值查找等操作。集合框架（Collections Framework）是 Java 提供的一套统一的数据容器体系，解决了这些问题。

对比项	数组	集合
长度	固定，创建后不可变	动态扩容
元素类型	可存基本类型	只能存引用类型（基本类型自动装箱）
功能	增删改查需手动实现	内置排序、查找、去重等方法
泛型支持	❌	✅

2. 集合框架体系

Java 集合框架分为两大体系：Collection（单值容器）和 Map（键值对容器）。

java.util
├── Collection<E>                        ← 单值容器根接口
│   ├── List<E>                          ← 有序、可重复
│   │   ├── ArrayList                    ← 动态数组，随机访问快
│   │   ├── LinkedList                   ← 双向链表，插删快
│   │   └── Vector（已过时）
│   │
│   ├── Set<E>                           ← 无序、不重复
│   │   ├── HashSet                      ← 基于 HashMap，无序
│   │   ├── LinkedHashSet                ← 保证插入顺序
│   │   └── TreeSet                      ← 按自然序/比较器排序
│   │
│   └── Queue<E>                         ← 队列
│       ├── LinkedList                   ← 也实现了 Queue
│       ├── PriorityQueue                ← 优先队列（堆）
│       └── Deque<E>
│           └── ArrayDeque               ← 双端队列，栈/队列首选
│
└── Map<K,V>                             ← 键值对容器根接口
    ├── HashMap                          ← 无序，允许 null key
    ├── LinkedHashMap                    ← 保证插入/访问顺序
    ├── TreeMap                          ← 按 key 排序
    ├── HashTable（已过时）
    └── ConcurrentHashMap                ← 线程安全的 HashMap

3. Collection 接口

Collection 是所有单值集合的根接口，定义了最基础的操作：

Collection<String> col = new ArrayList<>();

// 增
col.add("Apple");
col.addAll(List.of("Banana", "Cherry"));

// 删
col.remove("Apple");
col.clear();

// 查
col.contains("Banana");   // → true
col.size();               // → 元素数量
col.isEmpty();            // → 是否为空

// 遍历
for (String s : col) { ... }                          // for-each
col.forEach(s -> System.out.println(s));              // Lambda
Iterator<String> it = col.iterator(); while(it.hasNext()) { it.next(); }

4. List / Set / Queue 核心区别

特性	List	Set	Queue
有序（插入顺序）	✅	❌（TreeSet 按排序）	✅（FIFO）
可重复	✅	❌	✅
允许 null	✅	HashSet 允许一个 null	视实现而定
下标访问	✅ `get(i)`	❌	❌
典型实现	ArrayList	HashSet	ArrayDeque

5. Map 接口

Map 不继承 Collection，是独立的键值对体系：

Map<String, Integer> map = new HashMap<>();

// 增 / 改
map.put("Alice", 90);
map.putIfAbsent("Bob", 80);       // key 不存在才插入

// 删
map.remove("Alice");

// 查
map.get("Bob");                   // → 80，key 不存在返回 null
map.getOrDefault("Tom", 0);       // → 0（key 不存在时的默认值）
map.containsKey("Bob");           // → true
map.containsValue(80);            // → true

// 遍历
map.forEach((k, v) -> System.out.println(k + "=" + v));

for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "=" + entry.getValue());
}

6. 各实现类选型速查

6.1. List 选型

场景	推荐	原因
随机访问（按下标读取）	`ArrayList`	O(1) 随机访问
频繁头部插入 / 删除	`LinkedList`	O(1) 头尾操作
需要线程安全	`CopyOnWriteArrayList`	读多写少场景
普通业务开发	`ArrayList`	综合性能最佳 ✅

6.2. Set 选型

场景	推荐	原因
仅去重，不关心顺序	`HashSet`	O(1) 增删查
去重 + 保持插入顺序	`LinkedHashSet`	有序 HashSet
去重 + 自然排序	`TreeSet`	O(log N)，自动排序

6.3. Map 选型

场景	推荐	原因
通用键值存储	`HashMap`	O(1) 增删查，性能最佳 ✅
保持插入顺序	`LinkedHashMap`	有序 HashMap
按 key 排序	`TreeMap`	O(log N)，key 有序
实现 LRU 缓存	`LinkedHashMap`	accessOrder 模式
多线程并发	`ConcurrentHashMap`	线程安全，性能优于 HashTable

7. 集合与线程安全

默认情况下，大多数集合类不是线程安全的：

线程不安全（单线程使用）：
ArrayList / LinkedList / HashSet / HashMap

线程安全方案：
├── Collections.synchronizedList(list)      ← 包装成同步集合，性能差
├── CopyOnWriteArrayList                     ← 读多写少的 List
├── ConcurrentHashMap                        ← 高并发 Map 首选 ✅
└── Vector / HashTable                       ← 已过时，不推荐

8. 迭代器与 fail-fast 机制

Java 集合的迭代器实现了 fail-fast 机制：遍历过程中若集合被修改（增删），立即抛出 ConcurrentModificationException。

List<String> list = new ArrayList<>(List.of("a", "b", "c"));

// ❌ 遍历中直接删除，触发 fail-fast
for (String s : list) {
    if ("b".equals(s)) list.remove(s);  // 抛出 ConcurrentModificationException
}

// ✅ 使用 Iterator 的 remove 方法
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    if ("b".equals(it.next())) it.remove();  // 安全删除
}

// ✅ 使用 removeIf（Java 8+，推荐）
list.removeIf(s -> "b".equals(s));

9. 本章学习路线

集合框架总览（本篇）
      │
      ├──▶ 3.2 ArrayList    → 最常用，扩容原理、与数组区别
      ├──▶ 3.3 LinkedList   → 双向链表，与 ArrayList 对比
      ├──▶ 3.4 Set 三兄弟   → HashSet / LinkedHashSet / TreeSet
      ├──▶ 3.5 HashMap      → 重点！底层原理、扩容、面试高频
      ├──▶ 3.6 LinkedHashMap / TreeMap
      ├──▶ 3.7 ConcurrentHashMap → 线程安全，面试高频
      └──▶ 3.8 Collections 工具类