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

本阶段涵盖：异常处理与 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. 自定义异常（必背步骤）

定义异常类
继承 Exception（编译期）或 RuntimeException（运行时）
无参构造 + 有参构造（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 完全用红黑树实现

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

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

阶段03-异常处理与集合框架.md 7.7 KB History Raw