docs: 更新20260729课堂笔记，同步代码变更——新增集合框架入门(Collection Framework)：集合vs数组对比、体系结构(Collection/List/Set/Map)、线性表数据结构(栈/队列/数组/链表)；包装类代码移入course.packaging包

README.md

@@ -34,7 +34,7 @@
 | 2026-07-24 | [多态 + 多态中的转型 + 内部类：多态概念与前提、多态成员访问特点、向上转型/向下转型、instanceof类型判断、多态的好处（开闭原则）、抽象类与多态结合（Animal→Dog；Person→Student/Teacher综合案例）、Usb接口多态案例（NoteBook接入鼠标/猫）、内部类概念与使用场景、成员内部类、私有内部类设计原则](./课堂笔记/01-JavaSE基础-笔记/20260724-笔记.md) |
 | 2026-07-27 | [匿名内部类 + Java API 与 String 类 + Math + 日期时间：内部类三大分类、匿名内部类四种使用方式、综合案例（USB/餐具/学生排序/计算器/动物叫声）；API概念、String内存模型/不可变性/可变字符串StringBuffer&StringBuilder/文本块TextBlock JDK15+/String常用方法大全；Math数学类常用方法；日期时间类（Date/LocalDate/LocalTime/LocalDateTime/DateTimeFormatter）](./课堂笔记/01-JavaSE基础-笔记/20260727-笔记.md) |
 | 2026-07-28 | [Java 异常处理：异常概念、Throwable 体系结构、编译期/运行时异常、JVM 默认处理、try-catch 多 catch 块、异常常用方法、finally 资源关闭、throws 抛出、鲁棒性；自定义异常、throw/throws；Object 类：equals/hashCode/toString 重写、Objects 工具类；课后作业回顾 — String 分割去重/统计、LocalDate 天数差计算](./课堂笔记/01-JavaSE基础-笔记/20260728-笔记.md) |
-| 2026-07-29 | [包装类（Wrapper Classes）：基本类型与包装类对应关系、装箱与拆箱、自动装箱/拆箱、包装类优势、包装类缓存机制、包装类在 Bean 类中的应用](./课堂笔记/01-JavaSE基础-笔记/20260729-笔记.md) |
+| 2026-07-29 | [包装类（Wrapper Classes）+ 集合框架入门（Collection Framework）：基本类型与包装类对应关系、装箱与拆箱、自动装箱/拆箱、包装类优势、缓存机制、Bean 类应用；集合 vs 数组、体系结构（Collection/List/Set/Map）、线性表数据结构（栈/队列/数组/链表）](./课堂笔记/01-JavaSE基础-笔记/20260729-笔记.md) |
 
 ## 二、授课代码
 
@@ -55,7 +55,7 @@
 | 2026-07-24 | 多态概念与前提、多态成员访问特点、向上转型/向下转型、instanceof运算符、多态的好处（开闭原则）、抽象类+多态（Animal→Dog、Person→Student/Teacher→Test03.runPerson()）、接口多态（Usb→Mouse/Cat→NoteBook）、内部类概念与使用场景 | `c260724` | [`course/polymorphism`](./授课代码/c260724/src/course/polymorphism/) / [`course/internalClass`](./授课代码/c260724/src/course/internalClass/) |
 | 2026-07-27 | 匿名内部类：内部类三大分类概念回顾、匿名内部类语法格式与本质、三种使用方式（多态接收变量赋值 / 方法参数传递 / 匿名对象直接调用）、配套接口/抽象类定义（Usb / Tableware / Compute / Sort）、综合案例（NoteBook USB设备 / Person 餐具 / 学生排序比较 / Calculator计算器 / Animal动物叫声）；Java API：API概念、String类（内存模型/构造方法/==与equals/常用方法大全/不可变性）、可变字符串（StringBuffer/SringBuilder）、文本块TextBlock JDK15+；Math数学类；日期时间类（Date/LocalDate/LocalTime/LocalDateTime/DateTimeFormatter） | `c260727` | [`course/anonymousInternalClass`](./授课代码/c260727/src/course/anonymousInternalClass/) / [`course/api`](./授课代码/c260727/src/course/api/) / [`course/api/string`](./授课代码/c260727/src/course/api/string/) / [`course/api/math`](./授课代码/c260727/src/course/api/math/) / [`course/api/date`](./授课代码/c260727/src/course/api/date/) / [`exercise/exercise01`](./授课代码/c260727/src/exercise/exercise01/) / [`exercise/exercise06`](./授课代码/c260727/src/exercise/exercise06/) / [`exercise/exercise07`](./授课代码/c260727/src/exercise/exercise07/) / [`homework_0724/p2_myarray`](./授课代码/c260727/src/homework_0724/p2_myarray/) |
 | 2026-07-28 | 异常处理（Demo01~Demo04 + Person+AgeOutOfBoundsException） + Object类（Demo01+Person 重写equals/hashCode/toString） + 课后作业回顾（String工具 + 日期数学） + Exercises | `c260728` | [`course/api`](./授课代码/c260728/src/course/api/) / [`course/exception`](./授课代码/c260728/src/course/exception/) / [`homework260727`](./授课代码/c260728/src/homework260727/) / [`exercise/exercise01`](./授课代码/c260728/src/exercise/exercise01/) / [`exercise/exercise07`](./授课代码/c260728/src/exercise/exercise07/) |
-| 2026-07-29 | 包装类（Wrapper Classes）：装箱与拆箱、自动装箱/拆箱、包装类在 Bean 类中的应用（Person + Demo01） | `c260729` | [`course`](./授课代码/c260729/src/course/) |
+| 2026-07-29 | 包装类（Wrapper Classes）：装箱与拆箱、自动装箱/拆箱、包装类在 Bean 类中的应用（Person + Demo01） + 集合框架入门（Collection Framework）：集合 vs 数组、体系结构（Collection/List/Set/Map）、线性表数据结构（栈/队列/数组/链表） | `c260729` | [`course/packaging`](./授课代码/c260729/src/course/packaging/) / [`course/collection`](./授课代码/c260729/src/course/collection/) |
 
 ## 三、课堂练习题
 

授课代码/c260729/src/course/Demo01.java

@@ -1,56 +0,0 @@
-package course;
-
-/**
- * @author WanJl
- * @version 1.0
- * @title Demo01
- * @description 包装类 包装器类
- * @create 2026/7/29
- */
-public class Demo01 {
-    /*
-        Java中分为基本数据类型和引用数据类型
-        Java核心就是万事万物皆为对象
-        对象就一定有属性和方法。
-        但是Java中的8种基本数据类型却并没有对象、也没有属性也没有方法。
-        byte short int long float double char boolean
-        因为他们是从C/C++延续过来的，就是为了让C/C++程序员能够快速是学习和使用Java
-        但是严格来讲，基本数据类型并不符合Java的面向对象特性。
-        所以Java为了弥补，就为每个基本数据类型都设置了对应的引用数据类型，也就是包装器类。
-        byte    ----    Byte
-        short   ----    Short
-        int     ----    Integer
-        long    ----    Long
-        float   ----    Float
-        double  ----    Double
-        char    ----    Character
-        boolean ----    Boolean
-
-        包装器类是具有属性和方法的，属于引用数据类型
-
-        从 基本数据类型 --转换--> 引用数据类型  叫 装箱
-        从 引用数据类型 --转换--> 基本数据类型  叫 拆箱
-
-
-        使用包装器类，比使用基本数据类型要好在什么地方？
-        因为包装器类有属性有方法，我们可以操作这个数据。
-        都可以自动装箱和拆箱了，所以使用包装器类还是基本数据类型没有区别，
-        而且使用引用数据类型还可以使用它的属性和方法
-     */
-    public static void main(String[] args) {
-        int a=15;
-        Integer integer=new Integer(a); //装箱，但是在JDK9之后已经移除了，因为有了自动装箱
-
-        Integer i=a;
-        Integer i1=15;  //自动装箱 可以想String一样，直接赋值。
-
-        int a1 = integer.intValue();    //拆箱
-        System.out.println(a1);
-
-        int a2=i;       //自动拆箱
-        System.out.println(a2);
-
-
-    }
-
-}

授课代码/c260729/src/course/collection/Demo01.java

@@ -0,0 +1,51 @@
+package course.collection;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo
+ * @description 集合
+ * @create 2026/7/29
+ */
+public class Demo01 {
+    /*
+        集合是用来存储Java属性变量、对象的容器
+        我们可以称集合为集合容器。
+        和数组一样，都是容器，可以存储多个数据
+        但是和数组不一样的是：
+            数组的长度是不可变的，但是集合的长度是可变的
+            数组是可以存储基本数据类型和引用数据类型的
+            但是集合只能存引用数据类型，不能存储基本数据类型。
+            如果一定要存储基本数据类型，也只能存对应的包装器类。
+            数组中只能存储同一种数据类型，
+            但是集合中可以存储多种数据类型，但是不建议，建议存储单一类型。
+         集合的体系结构：
+            Java的集合可以分为：
+                单列集合 和 双列集合
+                Collection                 Map
+                   /\                       /\
+            List      Set                 HashMap
+            /\        /\                  TreeMap
+          ArrayList   HashSet             LinkedHashMap
+          LinkedList  TreeSet
+          Vector      LinkedHashSet
+
+        其中 Collection、Map、List、Set都是接口，只定义规则，不实现。
+        由他们的实现类进行实现。
+
+        Collection  单列集合
+                有序集合----List
+                无序集合----Set
+
+        Map      双列集合
+            双列由键和值组成，Key和Value
+                键   Key 是不能重复的，在集合中是唯一的
+                值   Value 是可以重复的。
+
+
+
+
+     */
+
+
+}

授课代码/c260729/src/course/collection/Demo02.java

@@ -0,0 +1,41 @@
+package course.collection;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo02
+ * @description
+ * @create 2026/7/29
+ */
+public class Demo02 {
+    /*
+    我们一般把集合 称为集合框架，因为集合是把一些底层数据结构进行了封装。
+        比如单列集合中的List
+        List直译就是列表，也就是对应数据结构中的  线性表结构
+        线性表结构大致可以分为四种：
+            栈结构：
+                先进后出，加入元素，称为 入栈、压栈。 移除元素，称为出栈、弹栈。
+            队列结构：
+                先进先出
+            数组结构：
+                是连续的数据存储，查询的时候可以通过索引快速定位，
+                增删的时候，需要修改前后进行移动。所以增删慢，查询快。
+            链表结构：
+                是不连续的存储，不需要在内存中开辟连续的存储空间，
+                只需要从头结点开始，每个节点都有一个执行下一个节点的指针(地址)。
+                随机查询的时候，需要从第1个结点开始依次向后查找，查询速度慢。
+                增删的时候，只需要改变临近结点的指针，就可以。所以增删速度快。
+
+            List的实现类对应的数据结构：
+                ArrayList：数组
+                LinkedList：队列、栈、链表
+
+
+
+
+
+
+
+     */
+
+}

授课代码/c260729/src/course/packaging/Demo01.java

@@ -0,0 +1,59 @@
+package course.packaging;
+
+/**
+ * @author WanJl
+ * @version 1.0
+ * @title Demo01
+ * @description 包装类 包装器类
+ * @create 2026/7/29
+ */
+public class Demo01 {
+    public Demo01() {
+    }
+
+    /*
+            Java中分为基本数据类型和引用数据类型
+            Java核心就是万事万物皆为对象
+            对象就一定有属性和方法。
+            但是Java中的8种基本数据类型却并没有对象、也没有属性也没有方法。
+            byte short int long float double char boolean
+            因为他们是从C/C++延续过来的，就是为了让C/C++程序员能够快速是学习和使用Java
+            但是严格来讲，基本数据类型并不符合Java的面向对象特性。
+            所以Java为了弥补，就为每个基本数据类型都设置了对应的引用数据类型，也就是包装器类。
+            byte    ----    Byte
+            short   ----    Short
+            int     ----    Integer
+            long    ----    Long
+            float   ----    Float
+            double  ----    Double
+            char    ----    Character
+            boolean ----    Boolean
+
+            包装器类是具有属性和方法的，属于引用数据类型
+
+            从 基本数据类型 --转换--> 引用数据类型  叫 装箱
+            从 引用数据类型 --转换--> 基本数据类型  叫 拆箱
+
+
+            使用包装器类，比使用基本数据类型要好在什么地方？
+            因为包装器类有属性有方法，我们可以操作这个数据。
+            都可以自动装箱和拆箱了，所以使用包装器类还是基本数据类型没有区别，
+            而且使用引用数据类型还可以使用它的属性和方法
+         */
+    public static void main(String[] args) {
+        int a=15;
+        Integer integer=new Integer(a); //装箱，但是在JDK9之后已经移除了，因为有了自动装箱
+
+        Integer i=a;
+        Integer i1=15;  //自动装箱 可以想String一样，直接赋值。
+
+        int a1 = integer.intValue();    //拆箱
+        System.out.println(a1);
+
+        int a2=i;       //自动拆箱
+        System.out.println(a2);
+
+
+    }
+
+}

授课代码/c260729/src/course/Person.java → 授课代码/c260729/src/course/packaging/Person.java

@@ -1,4 +1,4 @@
-package course;
+package course.packaging;
 
 /**
  * @author WanJl

课堂笔记/01-JavaSE基础-笔记/20260729-笔记.md

@@ -14,7 +14,7 @@ Java 中分为**基本数据类型**和**引用数据类型**。Java 的核心
 
 为了解决这个问题，Java 为每个基本数据类型都设置了对应的引用数据类型，即**包装器类（Wrapper Classes）**。
 
-> 📄 来源：`Demo01.java`
+> 📄 来源：`packaging/Demo01.java`
 
 ### 1.2 基本类型与包装类的对应关系
 
@@ -31,7 +31,7 @@ Java 中分为**基本数据类型**和**引用数据类型**。Java 的核心
 
 包装器类具有属性和方法，属于引用数据类型。
 
-> 📄 来源：`Demo01.java`
+> 📄 来源：`packaging/Demo01.java`
 
 ### 1.3 装箱（Boxing）与拆箱（Unboxing）
 
@@ -53,7 +53,7 @@ int a1 = integer.intValue(); // 调用 intValue() 方法拆箱
 int a2 = i;          // Integer → int，自动拆箱
 ```
 
-> 📄 来源：`Demo01.java`
+> 📄 来源：`packaging/Demo01.java`
 
 ### 1.4 自动装箱与拆箱的底层原理
 
@@ -84,7 +84,7 @@ public class Person {
 }
 ```
 
-> 📄 来源：`Person.java`
+> 📄 来源：`packaging/Person.java`
 
 ### 1.7 包装类的常用方法
 
@@ -126,9 +126,134 @@ System.out.println(c.equals(d));  // true
 
 ---
 
-## 二、随堂练习要点
+## 二、集合框架入门（Collection Framework）
 
-本日课程重点在于理解包装类的设计思想和使用方式：
+### 2.1 集合的概念
+
+**集合（Collection）** 是用来存储 Java 变量、对象的容器，也称为集合容器。
+
+与数组一样，集合也是容器，可以存储多个数据。但二者有显著区别：
+
+| 对比维度 | 数组 | 集合 |
+|---------|------|------|
+| **长度** | 一旦创建，长度不可变 | 长度可变，可动态增减 |
+| **存储类型** | 可存储基本数据类型和引用数据类型 | **只能存储引用数据类型**（若需存基本类型，须用对应的包装类） |
+| **元素类型** | 只能存储同一种数据类型（类型固定） | 可存储多种数据类型（但建议存储单一类型，以便泛型约束） |
+
+> 📄 来源：`collection/Demo01.java`
+
+### 2.2 集合的体系结构
+
+Java 的集合框架分为两大派系：
+
+```
+Collection（单列集合）          Map（双列集合）
+      / \                          / \
+  List    Set                  HashMap   TreeMap
+   /\      /\                 LinkedHashMap
+ArrayList  HashSet
+LinkedList TreeSet
+Vector     LinkedHashSet
+```
+
+- **Collection**、**Map**、**List**、**Set** 都是 **接口（Interface）**，只定义规则，不实现
+- 具体功能由它们的 **实现类** 完成
+
+**Collection（单列集合）**：
+- **List**（有序集合）：元素有顺序，可重复
+  - `ArrayList`：数组结构实现
+  - `LinkedList`：链表结构实现
+  - `Vector`：早期版本，线程安全
+- **Set**（无序集合）：元素无顺序，不可重复
+  - `HashSet`：哈希表实现
+  - `TreeSet`：红黑树实现（可排序）
+  - `LinkedHashSet`：可保持插入顺序
+
+**Map（双列集合）**：
+- 由 **键（Key）** 和 **值（Value）** 组成
+- **Key** 在集合中是唯一的，不能重复
+- **Value** 可以重复
+
+> 📄 来源：`collection/Demo01.java`
+
+### 2.3 List 与底层数据结构
+
+集合被称为**集合框架**，因为它把底层数据结构进行了封装。
+
+**List** 直译为"列表"，对应数据结构中的**线性表结构**。线性表结构大致分为四种：
+
+#### 2.3.1 栈结构（Stack）
+
+- **特点**：先进后出（LIFO — Last In First Out）
+- **操作术语**：
+  - 加入元素 → **入栈 / 压栈（push）**
+  - 移除元素 → **出栈 / 弹栈（pop）**
+
+```
+入栈顺序: A → B → C
+出栈顺序: C → B → A
+```
+
+#### 2.3.2 队列结构（Queue）
+
+- **特点**：先进先出（FIFO — First In First Out）
+
+```
+入队顺序: A → B → C
+出队顺序: A → B → C
+```
+
+#### 2.3.3 数组结构（Array）
+
+- 在内存中开辟一段**连续的空间**存储数据
+- **优点**：查询速度快，可通过索引快速定位（`arr[index]`）
+- **缺点**：增删速度慢，因为需要移动后续元素
+- **对应实现类**：`ArrayList`
+
+```
+索引: [0] [1] [2] [3] [4] [5]
+值:   10  20  30  40  50  60
+      ↑ 连续存储空间
+```
+
+#### 2.3.4 链表结构（Linked List）
+
+- 在内存中**不连续**存储，不需要开辟连续的存储空间
+- 每个节点（Node）包含数据 + 指向下一个节点的指针（地址）
+- **优点**：增删速度快，只需改变相邻节点的指针
+- **缺点**：随机查询速度慢，需要从头结点依次遍历查找
+- **对应实现类**：`LinkedList`
+
+```
+头结点 → Node1 → Node2 → Node3 → null
+        data    data    data
+        next→   next→   next→
+```
+
+#### 2.3.5 List 实现类的数据结构对应
+
+| 实现类 | 对应数据结构 | 查询特点 | 增删特点 |
+|--------|-------------|---------|---------|
+| `ArrayList` | 数组（Array） | 快（索引定位） | 慢（元素移动） |
+| `LinkedList` | 链表（Linked List）、队列（Queue）、栈（Stack） | 慢（从头遍历） | 快（改指针） |
+
+> 📄 来源：`collection/Demo02.java`
+
+---
+
+## 三、随堂练习要点
+
+### 本日课程知识点概览
+
+| 知识点 | 说明 | 对应文件 |
+|--------|------|---------|
+| 包装类概念 | 8种基本类型→包装类，装箱/拆箱 | `packaging/Demo01.java` |
+| 包装类在 Bean 中的应用 | `Integer` 替代 `int` | `packaging/Person.java` |
+| 包装类缓存机制 | -128~127 缓存池，`==` vs `equals()` | — |
+| 集合框架概述 | 集合 vs 数组对比，体系结构 | `collection/Demo01.java` |
+| 线性表数据结构 | 栈/队列/数组/链表 特点 | `collection/Demo02.java` |
+
+### 包装类重点
 
 1. **概念理解**：为什么 Java 需要包装类？基本类型和包装类各有什么优劣？
 2. **装箱/拆箱操作**：手动 vs 自动，理解编译器的底层转换逻辑
@@ -138,10 +263,20 @@ System.out.println(c.equals(d));  // true
    - 包装类对象参与算术运算时的自动拆箱
    - `null` 包装类拆箱会抛出 `NullPointerException`
 
+### 集合框架重点
+
+1. **理解集合 vs 数组的区别**：长度可变性、元素类型限制
+2. **记忆体系结构**：Collection（List / Set）和 Map 两大分支
+3. **掌握四种线性表结构**：栈（LIFO）、队列（FIFO）、数组（查询快增删慢）、链表（增删快查询慢）
+4. **关联实现类**：`ArrayList` → 数组，`LinkedList` → 链表/队列/栈
+
 ---
 
-## 三、拓展阅读
+## 四、拓展阅读
 
 - [Oracle Java 官方文档 — Autoboxing and Unboxing](https://docs.oracle.com/javase/tutorial/java/data/autoboxing.html)
 - [Java 包装类缓存机制详解](https://www.baeldung.com/java-integer-cache)
+- [Oracle Java 官方文档 — Collections Framework Overview](https://docs.oracle.com/javase/8/docs/technotes/guides/collections/overview.html)
+- [Java 集合框架详解：List、Set、Map 的区别](https://www.baeldung.com/java-collections)
 - 《Java 核心技术 卷I》第 3 章 — 包装器类与自动装箱
+- 《Java 核心技术 卷I》第 9 章 — 集合