# 阶段三：异常处理与集合框架 —— 核心知识点总纲

> 本阶段涵盖：**异常处理与 Object 类、包装类/集合框架/泛型、LinkedList 与手写链表、迭代器/Map 集合/二叉树**
> 细分文档：`按日细分/20260728-笔记.md` ~ `按日细分/20260731-笔记.md`
> 学生需要重点理解、背诵、掌握的理论核心知识点。

---

## 一、异常处理与 Object 类（对应 07-28）

### 1. 异常体系（必背）
```
Throwable
    ├── Exception（程序可处理）
    │     ├── RuntimeException（运行时异常：Arithmetic/ArrayIndexOutOfBounds/NullPointer...）
    │     └── 非 RuntimeException（编译期异常，必须处理：IOException、SQLException）
    └── Error（严重问题，无法处理：StackOverflowError、OutOfMemoryError）
```

### 2. 编译期异常 vs 运行时异常
- **编译期异常**：编译报错，必须捕获/抛出
- **运行时异常**：编译不报错，运行后才报错

### 3. 异常处理方式
- **try-catch**：多 catch 块**子类在前父类在后**
- **throws**：方法声明后抛出，谁调用谁处理
- **finally**：**无论是否异常都执行**（常用于资源关闭）；catch 有 return 时 finally 先执行
- 组合：`try-catch-finally`（完整）/ `try-catch` / `try-finally`（不处理但关资源）

### 4. 异常常用方法
`getMessage()`（最常用）/ `printStackTrace()` / `getCause()` / `fillInStackTrace()`

### 5. 自定义异常（必背步骤）
1. 定义异常类
2. 继承 `Exception`（编译期）或 `RuntimeException`（运行时）
3. 无参构造 + 有参构造（String message）

### 6. throw vs throws（必背）

| 维度 | throw | throws |
|------|-------|--------|
| 位置 | 方法体内 | 方法声明后 |
| 后跟 | 异常**对象** | 异常**类名** |
| 作用 | 实际抛出 | 声明有风险 |
| 数量 | 一次一个 | 一次多个 |

> 一句话：`throw` 是"干活的"，`throws` 是"贴告示的"。

### 7. Object 类（所有类的根父类）
- 三个方法：`equals()`、`hashCode()`、`toString()`
- **equals 默认 == 比较地址**；重写比较业务规则（null → 类型 → 字段）
- **equals 相等则 hashCode 必须相等**；重写 equals 必须重写 hashCode
- toString 默认 `包名.类名@哈希码`，重写便于输出对象
- **Objects 工具类**：`Objects.equals()` / `Objects.hash()` / `Objects.requireNonNull()`

## 二、包装类、集合框架与泛型（对应 07-29）

### 1. 包装类（必背）
**基本类型 ↔ 包装类：** int→Integer、char→Character、其余首字母大写（Byte/Short/Long/Float/Double/Boolean）

- **装箱**：基本 → 引用（自动装箱底层调 `valueOf()`）
- **拆箱**：引用 → 基本（自动拆箱底层调 `intValue()`）
- **缓存机制**：Integer 缓存 -128~127，范围内 `==` 为 true；超出新建
- ⚠️ **包装类比较用 equals，不用 ==**
- 常用方法：`Integer.parseInt(String)`、`valueOf()`、`intValue()`、`MAX_VALUE`

### 2. 集合 vs 数组（必背）

| 维度 | 数组 | 集合 |
|------|------|------|
| 长度 | 不可变 | 可变 |
| 存储 | 基本+引用 | **只能引用**（基本用包装类） |
| 类型 | 同一种 | 可多种（建议泛型） |

### 3. 集合体系（必背）
```
Collection（单列）            Map（双列）
  ├── List（有序可重复）       ├── HashMap
  │     ├── ArrayList（数组）  └── TreeMap
  │     └── LinkedList（链表）
  └── Set（无序不可重复）
        ├── HashSet（哈希表）
        ├── TreeSet（红黑树可排序）
        └── LinkedHashSet（保持插入顺序）
```

### 4. 四种线性表结构（必背）

| 结构 | 特点 | 实现 |
|------|------|------|
| 栈 | **先进后出 LIFO** | LinkedList |
| 队列 | **先进先出 FIFO** | LinkedList |
| 数组 | 连续，**查询快增删慢** | ArrayList |
| 链表 | 非连续，**增删快查询慢** | LinkedList |

### 5. ArrayList 底层（重点必背）
- 本质可变数组（`Object[] elementData`）
- 默认容量 **10**（懒加载，首次 add 才扩容）
- **1.5 倍扩容**：`oldCapacity + (oldCapacity >> 1)`
- `size` = 有效元素个数（非数组长度）；`size <= capacity`
- 构造：无参（容量0，首次加扩容10）/ 指定容量 / 传入集合
- 常用方法：`add/get/set/remove/size/isEmpty/contains/indexOf/toArray/getFirst/getLast`

### 6. 泛型（必背）
- **泛型（JDK1.5）**：编译时类型安全检测 + 避免强转
- 格式：`<E>`、`<K,V>`、`<T extends 父类>`（有界类型）
- **通配符**：`?` 无界、`? extends T` 上界、`? super T` 下界
- **始终优先使用泛型**，避免原始类型

## 三、LinkedList 与手写链表（对应 07-30）

### 1. List.of()（Java 9）
- **不可变集合**：不能 add/set/remove，抛 UnsupportedOperationException
- 不接受 null；元素对象本身可改（浅不可变）

### 2. LinkedList 双链表
- 基于**双链表**实现，同时实现 `List` + `Deque`
- 节点：`item` + `next` + `prev`
- **插入删除 O(1)、随机访问 O(n)**
- 头节点 prev=null；尾节点 next=null

### 3. ArrayList 方法时间复杂度（必背）
`get/set` O(1)；`add(尾部)` 均摊 O(1)；`add(index)/remove/contains/indexOf` **O(n)**

## 四、迭代器、Map 集合与二叉树（对应 07-31）

### 1. LinkedList 多接口形态
一个对象多种身份：`List`（列表）/ `Queue`（队列 offer/poll/peek）/ `Deque`（双端 addFirst/pollFirst/push/pop）
> 接口作为引用类型 = 能力限定（编译看左边）

### 2. Iterator 迭代器（必背）
- 所有单列集合都有 `iterator()`；**统一遍历方式**，适合无索引集合
- 方法：`hasNext()`（有无下一个）/ `next()`（取下一个并后移）
- 模板：`while (it.hasNext()) { it.next(); }`
- ⚠️ 指针单向移动；迭代中集合被修改抛 `ConcurrentModificationException`
- foreach 底层就是迭代器

### 3. Map 集合（必背）
- `Map<K,V>` 双列集合；**Key 唯一、Value 可重复**；**HashMap 无序**
- 常用方法：`put`（键存在=覆盖修改）/ `get` / `containsKey` / `remove` / `keySet` / `values` / `entrySet`
- **两种遍历**：
  - keySet + get：间接遍历（先拿键再反查值）
  - **entrySet**：直接遍历（getKey/getValue，效率更高）

### 4. HashMap 底层（必背）
- 结构 = **数组 + 链表**（JDK1.8 后：数组 + 链表/红黑树）
- 依赖 **hashCode + equals** 保证键唯一；自定义类型作 Key 必须重写两者
- 默认长度 **16**、负载因子 **0.75**
- **树化条件**：数组 > 64 **且** 链表 > 8；**退化条件**：链表 < 6
- JDK1.7 数组+链表；JDK1.8 链表超 8 转红黑树（防链表过长）

### 5. 二叉树理论（了解）
- 演进：二叉树 → 二叉搜索树（左小右大）→ AVL（左右高差 ≤1，左旋/右旋，LL/LR/RR/RL）→ **红黑树**
- **红黑树 6 条规则**：①红或黑 ②根黑 ③Nil 叶黑 ④红节点的子节点必须黑（不能双红）⑤任意节点到叶子简单路径黑节点数相同 ⑥插入默认红色
- TreeMap 完全用红黑树实现

## 本阶段必须背诵的核心口诀

1. **Exception 可捕获处理、Error 不可处理**
2. **多 catch 子类在前、父类在后**
3. **finally 无论是否异常都执行（用于关资源）**
4. **throw 抛对象、throws 声明类**
5. **equals 相等 hashCode 必相等**
6. **包装类比较用 equals（注意 -128~127 缓存）**
7. **集合只能存引用类型、长度可变**
8. **ArrayList 默认 10、1.5 倍扩容、size 是元素个数**
9. **List 有序可重复、Set 无序不可重复、Map 键唯一**
10. **HashMap 数组+链表（1.8 后+红黑树），树化需数组>64 且链表>8**
11. **Map 遍历：keySet 间接、entrySet 直接更高效**