依据 王道考研《数据结构》课程整理（本文件为全部章节的总笔记，随阅读逐章追加）。

第一章 绪论

1.0 开篇——数据结构在学什么？

数据结构在学什么？

• 如何用程序代码把现实世界的问题信息化；
• 如何用计算机高效地处理这些信息从而创造价值。

人类文明三次浪潮（阿尔文·托夫勒《第三次浪潮》）：

托夫勒："唯一可以确定的是，明天会使我们所有人大吃一惊。"

"信息化"：把现实事物用计算机表示。

学完 C 语言后，如何用计算机表示这些信息、并高效处理 → 这就是数据结构要解决的问题。

计算机系统分层（信息化世界）：一台计算机/手机 = 计组（硬件） → 操作系统 → C、数据结构（软件）；多台计算机之间通过计算机网络互联，构成"信息化世界"。

1.1 数据结构的基本概念

学习建议：概念多但较基础，抓大放小、形成框架。讨论一种数据结构时，关注"三要素"。

知识总览：

graph LR
    V[数据结构] --> A[基本概念]
    V --> B[三要素]
    A --> A1[数据]
    A --> A2[数据元素、数据项]
    A --> A3[数据对象、数据结构]
    A --> A4[数据类型、抽象数据类型 ADT]
    B --> B1[逻辑结构]
    B --> B2[物理结构（存储结构）]
    B --> B3[数据的运算]

1. 什么是数据

数据：信息的载体，是描述客观事物属性的数、字符及所有能输入到计算机中并被计算机程序识别和处理的符号的集合。数据是计算机程序加工的原料。（计算机内以二进制 0/1 表示。）

2. 数据元素、数据项

• 数据元素：数据的基本单位，通常作为一个整体来考虑和处理。
• 数据项：构成数据元素的不可分割的最小单位。
• 一个数据元素可由若干数据项组成；根据实际业务需求确定"什么是数据元素、什么是数据项"。 例：海底捞取号记录 = {号数、取号时间、就餐人数}；微博账号 = {昵称、性别、生日（年/月/日可为"组合项"）}。

3. 数据结构、数据对象

• 结构：各个元素之间的关系（如汉字"沙 / 粥 / 曼"的不同结构）。
• 数据结构：相互之间存在一种或多种特定关系的数据元素的集合。
• 数据对象：具有相同性质的数据元素的集合，是数据的一个子集。 例：数据结构 = 某个特定门店的排队顾客信息及其关系；数据对象 = 全国所有门店的排队顾客信息。

4. 数据结构的三要素

讨论一种数据结构要关注：逻辑结构、物理结构（存储结构）、数据的运算。

① 逻辑结构（数据元素之间的逻辑关系是什么？）：

graph LR
    L[逻辑结构] --> A[集合]
    L --> B[线性结构]
    L --> C[树形结构]
    L --> D[图状结构]

线性结构 = 一对一；集合、树形、图状结构 = 非线性结构。

② 物理结构（存储结构）（如何用计算机表示数据元素的逻辑关系？）：

链式、索引、散列属于非顺序存储。 绪论只需理解两点：①顺序存储元素物理上必须连续，非顺序存储可以离散；②存储结构会影响存储空间分配的方便程度（如"有人插队"）；③存储结构会影响对数据运算的速度（如"找第三个人"）。

③ 数据的运算：运算的定义针对逻辑结构（指出功能），运算的实现针对存储结构（指出操作步骤）。 例：队列逻辑结构（海底捞排队）定义运算：①队头元素出队；②新元素入队；③输出队列长度。

5. 数据类型、抽象数据类型（ADT）

数据类型：一个值的集合和定义在此集合上的一组操作的总称。

1. 原子类型：其值不可再分的数据类型（如 bool、int）。
2. 结构类型：其值可再分解为若干成分（分量）的数据类型（如 struct Customer{ int num; int people; }）。

抽象数据类型（ADT, Abstract Data Type）：抽象数据组织及与之相关的操作。用数学化的语言定义数据的逻辑结构、定义运算，与具体的实现无关。

重要结论：

• 定义了一个 ADT，就是定义了数据的逻辑结构、数据的运算，即定义了一个数据结构。
• 确定一种存储结构，就表示出了逻辑结构；存储结构不同，运算的具体实现也不同；确定了存储结构才能实现数据结构。
• 数据结构这门课看重的是数据元素之间的关系和对这些数据元素的操作，而不关心具体的数据项内容。

1.2.1 算法的基本概念

什么是算法？

• 程序 = 数据结构 + 算法（数据结构是要处理的信息；算法是处理信息的步骤）。
• 算法（Algorithm）：对特定问题求解步骤的一种描述，是指令的有限序列，其中的每条指令表示一个或多个操作。
• 例：做番茄炒蛋（食材+步骤）；对线性表按年龄递增排序（选择排序 Step1~Step4）。

程序设计 = 设计一个好的数据结构 + 设计一个好的算法。

算法的五个特性：

注：算法必须是有穷的，而程序可以是无穷的（如微信是程序，不是算法）。

"好"算法的特质（设计时要尽量追求的目标）：

1. 正确性：能正确地解决求解问题。
2. 可读性：描述要让别人看得懂（可由代码/伪代码/文字描述，重要的是无歧义）。
3. 健壮性：输入非法数据时能恰当地反应或处理，不产生莫名其妙的输出。
4. 高效率与低存储量需求：省时、省内存，即时间复杂度低、空间复杂度低。

1.2.2 算法的时间复杂度

如何评估算法时间开销？

• 让算法先运行、事后统计运行时间？存在问题：和机器性能、编程语言、编译程序指令质量有关；有些算法不能事后统计（如导弹控制算法）。
• 应事前预估：算法时间复杂度 = 事前预估算法时间开销 $T(n)$ 与问题规模 $n$ 的关系（T 表示 time）。

大 O 表示法：$T(n) = O(f(n))$，表示二者同阶/同等数量级（当 $n \to \infty$ 时二者之比为常数）。只考虑阶数高的部分，系数和低次幂可忽略。

计算规则：

• 加法规则：$T(n) = O(f(n)) + O(g(n)) = O(\max(f(n), g(n)))$ —— 多项相加，只保留最高阶项，系数变为 1。
• 乘法规则：$T(n) = O(f(n)) \times O(g(n)) = O(f(n)\times g(n))$ —— 多项相乘，都保留。

常用技巧：顺序执行的代码只影响常数项（忽略）；只需挑循环中的一个基本操作、分析其执行次数与 n 的关系；多层嵌套循环只需关注最深层循环循环了几次。

三种时间复杂度：

很多算法执行时间与输入数据有关（如顺序查找）；算法性能问题在 n 很大时才会暴露。

如何计算：①找一个基本操作（最深层循环）→ ②分析其执行次数 $x$ 与问题规模 $n$ 的关系 $x=f(n)$ → ③取 $O(x)$ 即 $T(n)$。

例题：

• 逐步递增：int i=1; while(i<=n){ i++; printf(...); } → $T(n)=3n+3=O(n)$。
• 指数递增：i=i*2 每次翻倍 → 最深层循环语句频度 $x$，结束时 $2^x>n$，$x=\log_2 n+1$ → $T(n)=O(\log_2 n)$。
• 顺序查找（数组中找元素 n）：最好 $O(1)$、最坏 $O(n)$、平均 $\frac{1+2+\dots+n}{n}=\frac{1+n}{2}$ → $O(n)$。

常见复杂度排序（口诀"常对幂指阶"）：

$$O(1) < O(\log_2 n) < O(n) < O(n\log_2 n) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)$$

1.2.3 算法的空间复杂度

空间复杂度：空间开销（内存开销）与问题规模 $n$ 的关系，记作 $S(n) = O(f(n))$（S 表示 Space）。

程序运行时的内存需求：

• 程序代码：大小固定，与问题规模无关；
• 数据：局部变量、参数等，其中与 $n$ 相关的变量才影响空间复杂度。

原地工作：算法所需内存空间为常量，即 $S(n) = O(1)$。（如算法1 逐步递增型爱你，无论 $n$ 怎么变，内存都是固定常量。）

例题：

递归的空间复杂度 = 递归调用的深度（若各层所需存储空间不同，分析方法略有区别）。

如何计算空间复杂度：

• 普通程序：①找到所占空间大小与问题规模相关的变量 → ②分析其所占空间 $x$ 与 $n$ 的关系 $x=f(n)$ → ③取 $O(x)$ 即 $S(n)$；
• 递归程序：找到递归调用的深度 $x$ 与 $n$ 的关系，取 $O(x)$ 即 $S(n)$。

常用技巧：同时间复杂度，加法/乘法规则、"常对幂指阶"（$O(1)<O(\log_2 n)<O(n)<O(n\log_2 n)<O(n^2)<O(n^3)<O(2^n)<O(n!)$）。

小结

1. 基本概念：数据、数据元素/数据项、数据对象/数据结构、数据类型/抽象数据类型 ADT。
2. 数据结构的三要素：逻辑结构（集合/线性/树形/图状，即线性与非线性）、物理结构/存储结构（顺序/链式/索引/散列，后三者非顺序）、数据的运算（定义针对逻辑结构、实现针对存储结构）。
3. 算法：程序 = 数据结构 + 算法；算法的五个特性（有穷性、确定性、可行性、输入、输出），"好"算法特质（正确、可读、健壮、高效低存储）。
4. 时间复杂度：$T(n)=O(f(n))$；加法/乘法规则；"常对幂指阶"；最好/最坏/平均。
5. 空间复杂度：$S(n)=O(f(n))$；原地工作 $O(1)$；递归空间 = 递归深度。
6. 主考点：定义了一个 ADT 就是定义了一个数据结构；存储结构影响运算实现；复杂度用大 O 只留最高阶。

第二章 线性表

2.1 线性表的定义和基本操作

线性表（Linear List）定义：是具有相同数据类型的 $n$（$n\ge0$）个数据元素的有限序列。$n$ 为表长，$n=0$ 时是空表。用 $L$ 命名线性表，一般表示为：

$$L = (a_1,\ a_2,\ \dots,\ a_i,\ a_{i+1},\ \dots,\ a_n)$$

特性：①元素个数有限；②元素类型相同（每个元素所占空间一样大）；③元素有次序。

重要术语：

• $a_i$ 是线性表中的"第 $i$ 个"元素——线性表中的位序（从 1 开始，注意数组下标从 0 开始，用数组实现线性表时要审题）。
• $a_1$ 是表头元素，$a_n$ 是表尾元素。
• 除第一个元素外，每个元素有且仅有一个直接前驱；除最后一个元素外，每个元素有且仅有一个直接后继。

Eg：所有整数按递增次序排列，是线性表吗？——否（无限序列，不是线性表）。

graph LR
    A1[a1] --> A2[a2] --> A3[a3] --> A4[a4] --> A5[a5]

基本操作（记忆思路：创销、增删改查）：

为什么要实现基本操作：①团队合作编程，定义的 ADT 要让人方便使用（封装）；②将常用操作封装成函数，避免重复工作、降低出错风险。 改、查（本质是"定位"）：改之前也要先"查"（LocateElem / GetElem）。

什么时候要传入参数的引用 &：对参数的修改结果需要"带回来"时。如 InitList(&L)、DestroyList(&L)、ListInsert(&L,i,e)、ListDelete(&L,i,&e)；而 LocateElem(L,e)、GetElem(L,i) 只读，不加 &。

void test(int &x){ x = 1024; ... }   // 引用传递，x 的修改"带回来了"
int x = 1;  test(x);                 // 调用后 x=1024

Tips：比起学会"How"，更重要的是想明白"Why"；函数命名要有可读性。

2.2.1 顺序表的定义

顺序表：用顺序存储的方式实现线性表。顺序存储把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。（即用"数组"存放数据元素。）

元素地址：设线性表第一个元素存放位置为 LOC(L)（location 的缩写），则第 $i$ 个元素地址 = LOC(L) + $(i-1)\times$ sizeof(ElemType)。用 C 语言 sizeof(ElemType) 得到元素大小（如 sizeof(int)=4B，sizeof(Customer)=8B）。

顺序表的实现——静态分配：

#define MaxSize 10                 // 定义最大长度
typedef struct {
    ElemType data[MaxSize];        // 用静态的"数组"存放数据元素
    int length;                    // 顺序表的当前长度
} SqList;                          // 顺序表类型定义（静态分配）

Sq = sequence（顺序、序列）。给数据元素分配连续存储空间，大小为 MaxSize × sizeof(ElemType)。

• 表长一开始就确定、无法更改（静态）。存满就"放弃治疗"；若一开始就声明很大的空间，又会浪费。

顺序表的实现——动态分配（静态数组存满无法扩容，用动态数组）：

#define InitSize 10
typedef struct {
    ElemType *data;    // 指示动态分配数组的指针
    int MaxSize;       // 顺序表的最大容量
    int length;        // 顺序表的当前长度
} SeqList;             // 动态分配方式

L.data = (ElemType *) malloc(sizeof(ElemType) * InitSize);   // 申请一片连续空间

• C 用 malloc / free（头文件 <stdlib.h>），C++ 用 new / delete。
• 动态扩容（IncreaseSize(&L, len)）：int *p = L.data; L.data = (int *) malloc((L.MaxSize + len) * sizeof(int)); for(...) L.data[i]=p[i]; L.MaxSize += len; free(p);
• 注：可用 realloc 实现，但建议初学者用 malloc / free 以理解过程；扩容要把旧数据复制到新区域，时间开销大（O(n)）。

顺序表的特点：

2.2.2_1 顺序表的插入和删除

插入：ListInsert(&L, i, e) —— 在表 L 的第 i 个位置插入元素 e。

bool ListInsert(SqList &L, int i, int e){
    if(i < 1 || i > L.length + 1) return false;   // 判断 i 的范围是否有效
    if(L.length >= MaxSize) return false;          // 当前存储空间已满，不能插入
    for(int j = L.length; j >= i; j--)             // 将第 i 个元素及之后的元素后移
        L.data[j] = L.data[j-1];
    L.data[i-1] = e;                               // 在位置 i 处放入 e
    L.length++;                                     // 长度 +1
    return true;
}

• 注意位序 i 与数组下标关系：元素后移时从表尾元素开始往前移动。
• 健壮性：if 判断 i 是否合法、空间是否已满，返回 bool 给使用者反馈。

插入时间复杂度（问题规模 n = L.length）：

删除：ListDelete(&L, i, &e) —— 删除表 L 第 i 个位置的元素，并用 e 返回其值。

bool ListDelete(SqList &L, int i, int &e){
    if(i < 1 || i > L.length) return false;   // 判断 i 的范围是否有效
    e = L.data[i-1];                           // 将被删除的元素赋值给 e
    for(int j = i; j < L.length; j++)          // 将第 i 个位置后的元素前移
        L.data[j-1] = L.data[j];
    L.length--;                                 // 长度 -1
    return true;
}

• 元素前移时从靠前的元素开始（与插入的后移相反，注意别弄反）。
• e 加了 &，因为要把删除的值"带回来"；不加 & 传的是复制品，改不回去。

删除时间复杂度（问题规模 n = L.length）：

2.2.2_2 顺序表的查找

按位查找：GetElem(L, i) —— 获取表 L 第 i 个位置的元素的值。

ElemType GetElem(SeqList L, int i){
    return L.data[i-1];      // 位序 i 对应数组下标 i-1
}

• 时间复杂度 $O(1)$：顺序表数据元素在内存中连续存放，根据起始地址 + 元素大小可立即定位第 i 个元素（随机存取特性）。
• 指针类型决定"步长"：data[i] = 起始地址 + i×sizeof(ElemType)；malloc 返回 void*，需强制转换成 ElemType*。

按值查找：LocateElem(L, e) —— 在表 L 中查找第一个元素值等于 e 的元素，返回其位序（找不到返回 0）。

int LocateElem(SeqList L, ElemType e){
    for(int i = 0; i < L.length; i++)
        if(L.data[i] == e)  return i + 1;   // 数组下标 i 对应位序 i+1
    return 0;                               // 退出循环，查找失败
}

• 基本数据类型（int、char、double、float…）可直接用 == 比较；
• 结构类型不能直接用 ==（C 语言会报错），需逐分量比较，或封装成 isCustomerEqual(a, b) 函数；考研初试手写代码可直接用 ==（主要考算法思想）。

按值查找时间复杂度（问题规模 n = L.length）：

2.3.1 单链表的定义

单链表：用链式存储（存储结构）实现了线性结构（逻辑结构）。每个结点存储一个数据元素，各结点间的先后关系用一个指针表示。

graph LR
    H[头指针 L] --> N1[a1] --> N2[a2] --> N3[a3] --> N4[a4] --> N5[NULL]

用代码定义一个单链表：

typedef struct LNode{      // 定义单链表结点类型
    ElemType data;         // 数据域，存放一个数据元素
    struct LNode *next;    // 指针域，指向下一个结点
}LNode, *LinkList;

• typedef <数据类型> <别名>：给类型重命名。LNode 是结点类型，LinkList 等价于 LNode *。前者强调"是一个结点"，后者强调"这是一个单链表"，合适的地方用合适的名字可读性更高。
• 新建结点：LNode * p = (LNode *) malloc(sizeof(LNode));（malloc 返回 void*，需强制转换）。

两种实现方式：带头结点 / 不带头结点（头结点不存放数据，只是为了操作方便）：

头指针 L 就代表整个单链表；因为要修改头指针，InitList 的参数要加 & 引用。

2.3.2_1 单链表的插入和删除

插入：

① 按位序插入 ListInsert(&L, i, e)：在第 i 个位置插入元素 e，核心是找到第 i-1 个结点，把新结点插到它后面。

bool ListInsert(LinkList &L, int i, ElemType e){
    if(i < 1) return false;
    LNode *p; int j = 0;
    p = L;                                // 头结点看作第 0 个结点
    while(p != NULL && j < i-1){ p = p->next; j++; }   // 找到第 i-1 个结点
    if(p == NULL) return false;
    LNode *s = (LNode *) malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;                    // 先连（顺序不能颠倒）
    p->next = s;                          // 再断
    return true;
}

• 时间复杂度：最好 $O(1)$（插表头 i=1），最坏 $O(n)$（插表尾），平均 $O(n)$。
• 不带头结点：不存在"第 0 个"结点，i=1 需特殊处理（改头指针 L）。

② 指定结点的后插 InsertNextNode(p, e)：s->next = p->next; p->next = s; —— $O(1)$。

③ 指定结点的前插 InsertPriorNode(p, e)：偷天换日——把新结点 s 插到 p 后面，再交换数据，$O(1)$：

s->next = p->next; p->next = s;
s->data = p->data;      // 把 p 中元素复制到 s
p->data = e;            // p 覆盖为 e

删除：

① 按位序删除 ListDelete(&L, i, &e)：找到第 i-1 个结点，令其指向第 i+1 个结点，释放第 i 个结点。

bool ListDelete(LinkList &L, int i, ElemType &e){
    if(i < 1) return false;
    LNode *p; int j = 0; p = L;
    while(p != NULL && j < i-1){ p = p->next; j++; }
    if(p == NULL) return false;
    if(p->next == NULL) return false;      // 第 i-1 个结点之后已无其余结点
    LNode *q = p->next;
    e = q->data;
    p->next = q->next;                     // 将 *q 从链中"断开"
    free(q);
    return true;
}

• 时间复杂度：最好 $O(1)$（删表头），最坏/平均 $O(n)$。

② 指定结点的删除 DeleteNode(p)：

• 方法 1：传入头指针，循环找到 p 的前驱，改前驱的 next。
• 方法 2：偷天换日——把 p->next 的数据复制到 p，再删除 p->next，$O(1)$。

  有坑：p 是最后一个结点时（p->next == NULL），方法 2 要特殊处理。

Tips：这些代码都要会写；注意审题（带头否？）；体会"封装"的好处。

2.3.2_2 单链表的查找

按位查找 GetElem(L, i)：返回第 i 个结点（头结点看作第 0 个结点）。

LNode * GetElem(LinkList L, int i){
    if(i < 0) return NULL;
    LNode *p; int j = 0;
    p = L;                                       // 头结点为第 0 个结点
    while(p != NULL && j < i){ p = p->next; j++; }
    return p;                                     // i 超过表长时返回 NULL
}

• 时间复杂度 $O(n)$：[单链表不具备"随机访问"特性，只能依次扫描]（对比顺序表是 $O(1)$）。
• 王道书版本用 j=1; p=L->next；if(i==0) return L; if(i<1) return NULL;。

按值查找 LocateElem(L, e)：返回第一个数据域等于 e 的结点指针，找不到返回 NULL。

LNode * LocateElem(LinkList L, ElemType e){
    LNode *p = L->next;                          // 从第 1 个结点开始查找
    while(p != NULL && p->data != e) p = p->next;
    return p;
}

• 平均时间复杂度 $O(n)$。（ElemType 是复杂结构类型时需逐分量比较，同顺序表。）

求单链表长度 Length(L)：

int Length(LinkList L){
    int len = 0; LNode *p = L;
    while(p->next != NULL){ p = p->next; len++; }
    return len;
}

• 时间复杂度 $O(n)$。

对比：顺序表可"随机存取"（$O(1)$ 按位访问）；单链表只能依次扫描，三种基本操作（按位插入/删除/查找）平均都是 $O(n)$。写循环扫描时要注意边界条件。

第十二章：集合高级

集合是长度可变的容器。Java 集合按"单列/双列"分为两大体系：单列（一次添加一个元素，对应 Collection 接口）和双列（一次添加两个元素即键值对，对应 Map 接口）。本篇覆盖 Collection、List、常用数据结构、ArrayList / LinkedList 以及泛型基础。

一、集合体系结构

整体划分：

List 与 Set 的核心区别：

<span style="color:orange">注意</span>：单列集合调用 add(元素)，双列集合调用 put(键, 值)。

二、Collection 接口的使用

Collection 是所有单列集合的父接口，其内部方法（add / remove / contains / …）所有单列集合都可以使用。

<span style="color:red">⚠ 关键点</span>：remove() 与 contains() 方法底层依赖对象的 equals 方法判断是否相等。若集合中存的是自定义对象（如 Student），未重写 equals 时会调用 Object.equals（比地址），需重写才能按内容比较。

三、集合的通用遍历方式

通用遍历方式有三种，Set 没有索引不能用普通 for 循环，所以后两种才真正"通用"。

普通 for（仅 List）：

ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < list.size(); i++) {
    String s = list.get(i);
}

迭代器：

Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    System.out.println(s);
}

<span style="color:orange">注意</span>：next() 方法会取出当前元素并将指针向后移动一位。调用次数不能超过 hasNext() 的次数，否则抛 NoSuchElementException。

增强 for（语法糖）：

for (String s : list) {          // 内部就是 Iterator
    System.out.println(s);
}

四、List 接口

List 因为支持索引，所以在 Collection 基础上多了一组"索引操作"的独特 API。

List 接口的 5 种遍历方式：迭代器 Iterator、增强 for、foreach 方法、普通 for 循环、列表迭代器 ListIterator。

4.1 并发修改异常

使用迭代器遍历集合的过程中，调用了集合对象的 add / remove 方法，就会出现 ConcurrentModificationException（并发修改异常）。

// 错误写法：会抛 ConcurrentModificationException
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if ("xxx".equals(s)) {
        list.remove(s);          // ❌
    }
}

// 正确写法：用迭代器自己的 remove()
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if ("xxx".equals(s)) {
        it.remove();             // ✅
    }
}

五、数据结构

集合的"底层"就是数据结构：ArrayList 用数组，LinkedList 用链表，Stack / Queue 用栈 / 队列。理解数据结构才能选对集合。

5.1 栈（Stack）

栈是一种 <span style="color:blue">先进后出</span>（后进先出） 的线性表，像弹匣——只有一端开口（栈顶），另一端封闭（栈底）。

flowchart TB
  A["数据A"] -->|压栈| B["数据A 数据B"]
  B -->|压栈| C["数据A 数据B 数据C"]
  C -->|弹栈| B
  B -->|弹栈| A

5.2 队列（Queue）

队列是 <span style="color:blue">先进先出</span> 的线性表，像排队——两端都开口。

5.3 数组（Array）

数组在内存中连续存储，每个元素有固定下标（索引）。

5.4 链表（Linked List）

链表中的结点是独立的内存块，结点之间通过"下一个结点地址"串联，内存不连续。

单向链表 vs 双向链表：

链表的插入过程（在数据 A、C 之间插入 B）：

1. 数据 B 对应的下一个数据地址指向数据 C
2. 数据 A 对应的下一个数据地址指向数据 B

六、ArrayList 类

ArrayList 底层是数组实现的，因此根据索引查询元素快，增删相对慢。

6.1 长度可变原理

flowchart LR
  S1["1. 底层创建 长度 10 的空数组"] --> S2["2. 存满后扩容 原数组 × 1.5"]
  S2 --> S3["3. 拷贝原数据 到新数组"]
  S3 --> S4["4. 添加新元素 到新数组"]

四步概括：① 初始长度 10 的空数组 → ② 存满后扩容 1.5 倍 → ③ 旧数据拷贝到新数组 → ④ 新元素添加到新数组。

6.2 源码解析

6.3 LinkedList 类

LinkedList 底层基于双链表实现：查询元素慢，增删首尾元素非常快。

<span style="color:orange">思考</span>：LinkedList 也有 get(int index) 方法，表面看起来是根据索引获取元素，实际上要从头 / 尾开始逐个查找，所以查询性能差；如果大量查询请用 ArrayList，大量首尾增删请用 LinkedList。

七、泛型（Generics）

JDK5 引入的特性，可以在编译阶段约束操作的数据类型，并进行检查。

7.1 泛型的好处

1. 统一数据类型
2. 将运行期的错误提升到编译期（编译时就能发现类型不匹配）

<span style="color:red">⚠ 注意事项</span>：泛型中只能编写引用数据类型，不能写基本类型（要用包装类：int → Integer、double → Double）。

// ❌ 错误
ArrayList<int> list = new ArrayList<>();

// ✅ 正确
ArrayList<Integer> list = new ArrayList<>();

7.2 泛型类

在类名后用 <E> 声明类型占位符，类中即可用 E 表示"某种类型"。

public class ArrayList<E> {
    public boolean add(E e) { ... }
}

7.3 泛型方法

// 非静态：使用类上声明的 E
public class ArrayList<E> {
    public boolean add(E e) { ... }
}

// 静态：必须自己声明 <T>
public static <T> void printArray(T[] array) { ... }

7.4 泛型接口

类实现带泛型的接口时，有两种操作方式：

1. 实现接口时直接确定类型：public class ArrayList<E> implements List<E>
2. 保持接口的泛型，等创建对象时再确定：public class ArrayList<E> implements List<E>

7.5 泛型通配符 ?

用于方法形参接收"任意类型"的集合，常配合上下限 ? extends T / ? super T 使用（进阶内容，留到后续章节）。

集合高级（2）

本篇聚焦 Set 家族（TreeSet / HashSet / LinkedHashSet）和 Map 家族（HashMap / LinkedHashMap / TreeMap）的实现原理、API 与遍历方式，以及 Collections 工具类的常用方法（含可变参数）。

一、Set 集合介绍

Set 接口是 Collection 的子接口。Set 实现类有 3 个：TreeSet / HashSet / LinkedHashSet，整体特点是：存取顺序不一致，没有跟索引有关的方法，不能存储重复元素。

<span style="color:orange">注意</span>：Set 没有索引，三种通用遍历方式（迭代器 / 增强 for / foreach）都可用，普通 for 循环不可用。

二、TreeSet 集合

TreeSet 特点是元素按规则排序（默认自然排序 / 自定义比较器），本质底层是红黑树（一种自平衡的二叉查找树）。

2.1 底层数据结构演进

2.2 两种排序方式

TreeSet 支持两种排序方式：自然排序（元素自身实现 Comparable）和比较器排序（构造时传入 Comparator）。

自然排序三步骤：

1. 类实现 Comparable 接口
2. 重写 compareTo 方法
3. 根据 compareTo 返回值组织排序规则：<span style="color:red">负数：左边走</span>、<span style="color:green">正数：右边走</span>、0：不存

public class Student implements Comparable<Student> {
    @Override
    public int compareTo(Student o) {
        return this.age - o.age;   // 按年龄升序
    }
}

<span style="color:orange">注意</span>：TreeSet 取出的顺序是左中右（中序遍历），张三, 23 李四, 24 王五, 25 赵六, 26。

比较器排序：当同具备自然排序和比较器排序时，会优先按照比较器进行排序操作。当 String / Integer / Double 等内置自然排序规则不符合需求时（如 String 是字典序，需要按长度排），使用比较器排序。

三、HashSet 集合

HashSet 特点：<span style="color:green">元素唯一</span>、不保证顺序。底层是哈希表，因此存取速度快。

3.1 hashCode 与 equals 配合流程

哈希值是一个 int 类型的随机值，Java 中每个对象都有一个哈希值（由 Object.hashCode() 底层 C++ 计算）。自定义对象必须按"内容"实现 hashCode + equals，否则重复元素识别不出来。

hashCode 的作用：定位元素应存入哪个桶（数组下标）；equals 的作用：同一桶内的元素去重判断。

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age && Objects.equals(name, student.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

<span style="color:red">⚠ 关键点</span>：根据对象内容生成 hash 值，不同的对象 hash 值也可能相等（如 "重地" 和 "通话"），这种现象叫 <span style="color:red">哈希碰撞</span>。

3.2 HashSet 底层原理

HashSet 底层就是 HashMap，存储流程基于哈希表（JDK 8 前后结构不同）。

哈希表存储数据的详细流程：

flowchart TD
  S1["① 创建默认长度16的数组（加载因子 0.75）"] --> S2["② 用元素的哈希值跟数组长度 计算应存入的位置"]
  S2 --> S3{"③ 该位置是否为 null?"}
  S3 -->|是 null| S4["直接存入"]
  S3 -->|不为 null| S5["④ 调用 equals 比较"]
  S5 -->|相等| S6["不存"]
  S5 -->|不相等| S7["存入（挂到链表中）"]
  S4 --> S8["⑤ 存满到 16×0.75=12 时 自动扩容为原长度的 2 倍"]

<span style="color:orange">注意</span>：JDK 8 之前是新元素占老元素位置、老元素挂下面；JDK 8 之后是新元素直接挂在老元素下面。当链表长度超过 8 且数组长度 ≥ 64时，链表自动转成红黑树提升查询性能。

四、LinkedHashSet 集合

LinkedHashSet 依然是基于哈希表（数组 + 链表 + 红黑树）实现的，但每个元素额外多了一个双向链表机制记录前后元素位置——所以保证存取顺序。

• 元素唯一 ✔（继承自 HashSet）
• 保证存取顺序 ✔（多了一条双向链表）
• 效率<span style="color:red">低于</span>HashSet（多维护一条链表）

五、Collections 工具类

java.util.Collections 是集合工具类，提供操作集合的静态方法。

5.1 可变参数（Varargs）

可变参数用在形参中可以接收多个数据，本质在方法内部就是一个数组。

调用方式灵活：可以不传参数、传 1 个或多个、传一个数组。

<span style="color:red">⚠ 注意事项</span>：

1. 一个形参列表中可变参数只能有一个
2. 可变参数必须放在形参列表的最<span style="color:red">后面</span>

public static int sum(int... nums) {     // 本质 int[] nums
    int total = 0;
    for (int n : nums) total += n;
    return total;
}

sum();              // 0
sum(1, 2, 3);       // 6
sum(new int[]{1,2});// 3

六、Map 集合介绍

Map 是<span style="color:green">键值对集合</span>，一次添加两个元素。需要存储一对应的数据时，优先考虑 Map。

三个实现类的值都不做要求（可重复、可为 null）。

6.1 常见 API

Map 是双列集合的顶层接口，它的功能是全部双列集合都可以使用的。

6.2 三种遍历方式

方式 1：通过键找值（分 3 步）

Set<String> keys = map.keySet();          // ① 获取所有键
for (String key : keys) {                 // ② 遍历 Set 集合
    String value = map.get(key);          // ③ 根据键找值
    System.out.println(key + "=" + value);
}

方式 2：通过键值对对象（核心是 Map.Entry）

// Map.Entry 内部接口的方法
K getKey();      // 获取键
V getValue();    // 获取值

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

方式 3：通过 forEach（Lambda）

map.forEach((key, value) -> System.out.println(key + "=" + value));

七、Map 集合的实现类

7.1 HashMap 底层原理

HashMap 与 HashSet 底层结构完全相同：哈希表。

map.put("键", "值") 的存储过程：

flowchart LR
  A["利用键计算哈希值 跟值无关"] --> B["根据哈希值与数组长度 计算应存入位置"]
  B --> C{"该位置是否 为 null?"}
  C -->|是| D["Entry 对象直接存入"]
  C -->|否| E["调用 equals 比较"]
  E -->|相等| F["值覆盖"]
  E -->|不相等| G["挂到链表中"]

7.2 LinkedHashMap

底层是哈希表 + 双向链表，与 LinkedHashSet 同理——哈希表保证键唯一，双向链表保证存取顺序。

7.3 TreeMap

底层是红黑树，键按排序组织。Comparable / Comparator 两种排序方式与 TreeSet 一致。

八、Set / List / Map 选择速查

九、练习：统计字符出现次数

需求：字符串 aababcabcdabcde，统计每个字符出现次数，按 a(5)b(4)c(3)d(2)e(1) 格式输出。

public class CharCount {
    public static void main(String[] args) {
        String s = "aababcabcdabcde";
        Map<Character, Integer> map = new LinkedHashMap<>(); // 保证输出顺序
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            map.merge(c, 1, Integer::sum);     // 简化 put 逻辑
        }

        StringBuilder sb = new StringBuilder();
        map.forEach((k, v) -> sb.append(k).append('(').append(v).append(')'));
        System.out.println(sb);                 // a(5)b(4)c(3)d(2)e(1)
    }
}

<span style="color:orange">注意</span>：用 LinkedHashMap 而不是 HashMap，是为了保证输出顺序与首次出现顺序一致。

第十三章：Stream 流

<span style="color:blue">Stream 流</span> 配合 Lambda 表达式使用，可以<span style="color:green">简化集合和数组操作</span>。其思想类似"工厂流水线"：原料（数据）→ 加工（中间方法）→ 出厂（终结方法），每一步都可以灵活组合，写出链式编程风格的代码。

一、Stream 流思想三步骤

flowchart LR
  A["① 将数据到流中 （获取流对象）"] --> B["② 中间方法 过滤/转换/去重..."]
  B --> C["③ 终结方法 遍历/统计/收集"]

二、获取 Stream 流对象

共有 3 种获取方式，根据数据来源选择。

// ① 集合
List<String> list = ...;
Stream<String> s1 = list.stream();

// ② 数组
Integer[] arr = {1, 2, 3};
Stream<Integer> s2 = Arrays.stream(arr);

// ③ 零散数据
Stream<String> s3 = Stream.of("a", "b", "c");

三、Stream 中间操作方法

中间方法调用后返回新的 Stream，支持链式编程。

<span style="color:red">⚠ 注意事项</span>：如果流对象已经被消费过，就不允许再次使用。每个流对象只能终结一次，多次调用终结方法会抛 IllegalStateException。

// 链式编程：用 limit + concat + distinct 一气呵成
Stream<String> s1 = list.stream().limit(4);
Stream<String> s2 = list.stream().skip(2);
Stream<String> s3 = Stream.concat(s1, s2);
s3.distinct().forEach(System.out::println);   // 消费 s3 后流就关闭

四、Stream 终结操作方法

终结方法调用后流被关闭，链式结束。

五、Stream 收集操作

Stream 流操作不会修改数据源，操作完成后若需要重新得到集合/数组，需要用 collect 方法。

// 把流中的数据转回集合
R collect(Collector collector);

Collectors 工具类提供 3 种常用收集方式：

5.1 收集到 Map 示例

需求：将 ArrayList 中的 "zhangsan,23" / "lisi,24" / "wangwu,25" 收集到 Map<姓名, 年龄>。

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "zhangsan,23", "lisi,24", "wangwu,25");

Map<String, Integer> map = list.stream()
        .collect(Collectors.toMap(
                s -> s.split(",")[0],   // 键：姓名
                s -> Integer.parseInt(s.split(",")[1])  // 值：年龄
        ));
// {zhangsan=23, lisi=24, wangwu=25}

5.2 综合练习：演员信息处理

需求：两个 ArrayList 集合分别存储 6 名男演员和 6 名女演员。

1. <span style="color:green">男演员只要名字为 3 个字的前两人</span>
2. <span style="color:green">女演员只要姓林的，并且不要第一个</span>
3. 把过滤后的男演员姓名和女演员姓名<span style="color:orange">合并</span>到一起
4. 把合并后的元素作为构造方法的参数创建 Actor 对象，遍历数据
5. 演员类 Actor 含一个成员变量、一个带参构造方法、对应 get / set 方法

// 演员类
public class Actor {
    private String name;
    public Actor(String name) { this.name = name; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
}

// 处理
ArrayList<String> males = new ArrayList<>(Arrays.asList(
        "蔡徐坤", "李易峰", "王俊凯", "易烊千玺", "陈伟霆", "邓伦"));
ArrayList<String> females = new ArrayList<>(Arrays.asList(
        "林允儿", "林志玲", "杨幂", "赵丽颖", "刘亦菲", "林心如"));

Stream<String> m = males.stream().filter(s -> s.length() == 3).limit(2);
Stream<String> f = females.stream().filter(s -> s.startsWith("林")).skip(1);
Stream.concat(m, f).map(Actor::new).forEach(a -> System.out.println(a.getName()));

第十四章：异常

<span style="color:blue">异常</span> 指的是程序在编译或执行过程中，出现的非正常的情况（错误）。常见如 ArrayIndexOutOfBoundsException / ClassCastException / NullPointerException。语法错误不是异常。

一、异常体系

flowchart TD
  T["Throwable"] --> E["Error"]
  T --> X["Exception"]
  X --> R["RuntimeException 及其子类"]
  X --> C["除 RuntimeException 之外 所有的异常"]

1.1 Exception 两大类

<span style="color:orange">注意</span>：编译时异常不报错，运行时可能报错；编译时异常没继承 RuntimeException，编译阶段就会出错。

二、异常的默认处理流程

不做任何处理时，JVM 的默认行为：

flowchart TD
  A["① 虚拟机在出现异常的代码处 自动创建异常对象"] --> B["② 异常从方法出现的点抛出给调用者 调用者最终抛出给 JVM"]
  B --> C["③ JVM 收到异常后 在控制台输出异常信息"]
  C --> D["④ 终止 Java 程序运行"]

三、异常处理方式

Java 提供 <span style="color:blue">2 种</span> 主动处理方式：捕获（try...catch）和抛出（throws / throw）。

3.1 try...catch：捕获异常

优点：程序可以继续往下执行。

try {
    // 可能会出现异常的代码
} catch (异常类型1 变量) {
    // 处理异常的方案
} catch (异常类型2 变量) {
    // 处理异常的方案
}

<span style="color:red">⚠ 关键点</span>：如果使用多个 catch，最大的异常需要放在最后（父类在后）。

Throwable 常见方法：

3.2 throws：抛出异常

用在方法名后面，声明"这个方法存在异常，但不做处理，交给调用方处理"。

public void method() throws 异常1, 异常2, 异常3... { }

<span style="color:red">⚠ 关键点</span>：子类重写父类方法时，不能抛出父类没有的异常，或者比父类更大的异常。

3.3 两种方式怎么选

思路：看这个问题是否需要暴露出来 → <span style="color:green">需要：抛出</span>，<span style="color:green">不需要：try...catch</span>。

3.4 throw vs throws

<span style="color:orange">细节</span>：抛出的异常对象如果是<span style="color:red">编译时异常</span>，必须使用 throws 声明；如果是<span style="color:green">运行时异常</span>，则不需要写 throws。

四、自定义异常

Java 无法为这个世界上全部的问题提供异常类。当企业想用异常管理某个业务问题时，需要自定义异常类。

4.1 两类自定义异常

4.2 示例：自定义业务异常

// 1. 自定义运行时异常
public class AgeOutOfRangeException extends RuntimeException {
    public AgeOutOfRangeException() { super(); }
    public AgeOutOfRangeException(String message) { super(message); }
}

// 2. 业务方法中抛出
public void setAge(int age) {
    if (age < 0 || age > 150) {
        throw new AgeOutOfRangeException("年龄超出范围: " + age);
    }
    this.age = age;
}

// 3. 调用方捕获
try {
    setAge(200);
} catch (AgeOutOfRangeException e) {
    System.out.println(e.getMessage());   // 年龄超出范围: 200
}

<span style="color:green">好处</span>：通过自定义异常可以精准表达特定错误（比通用 Exception 更有语义）。

第十五章：File 类、递归

File 类是操作系统文件对象（文件、文件夹）的 Java 封装，本章先掌握 File 的 API，再学习递归——用 File 遍历多层目录的关键。

一、File 类创建对象

File 封装的对象仅仅是一个路径名，这个路径可以存在，也可以不存在。

1.1 绝对路径 vs 相对路径

二、File 类常用 API

2.1 判断方法

2.2 获取信息方法

2.3 创建和删除方法

<span style="color:red">⚠ 关键点</span>：delete() 方法只能删除空文件夹，且不走回收站（不可恢复）。

2.4 遍历方法

<span style="color:orange">注意</span>：listFiles() 返回值的 4 种情况：

• 路径<span style="color:red">不存在</span> → 返回 null
• 路径是<span style="color:red">文件</span> → 返回 null
• 路径是<span style="color:green">空文件夹</span> → 返回长度为 0 的数组
• 路径是<span style="color:red">需权限</span>才能访问的文件夹 → 返回 null

三、递归

<span style="color:blue">递归</span> 是指方法直接或者间接调用本身。它的核心思路是：将大问题层层转化为与原问题相似、规模更小的问题来解决。

<span style="color:red">⚠ 关键点</span>：递归如果没有控制好终止，会出现递归死循环，导致<span style="color:red">栈内存溢出</span>（StackOverflowError）。

3.1 案例：求 5 的阶乘

推导：5! = 5 × 4!、4! = 4 × 3!、…、1! = 1。

public class RecursionDemo1 {
    public static void main(String[] args) {
        int result = jc(5);
        System.out.println(result);   // 120
    }

    public static int jc(int num) {
        if (num == 1) {
            return 1;                    // 终止条件
        }
        return num * jc(num - 1);        // 自己调自己，参数规模更小
    }
}

递归栈帧：

flowchart LR
  A["jc(5) return 5*24"] --> B["jc(4) return 4*6"]
  B --> C["jc(3) return 3*2"]
  C --> D["jc(2) return 2*1"]
  D --> E["jc(1) return 1"]

3.2 案例：不死神兔（斐波那契数列）

题目：一对兔子，从出生后第 3 个月起每个月都生一对兔子，小兔子长到第 3 个月后又生一对。假设兔子都不死，问第 20 个月的兔子对数为多少？

规律：从第 3 个月开始，兔子对数 = 前两个月之和。

public static int rabbit(int month) {
    if (month == 1 || month == 2) return 1;
    return rabbit(month - 1) + rabbit(month - 2);
}

3.3 递归使用场景

常用于逻辑类似的业务：文件遍历、目录树、阶乘、斐波那契等。

四、递归案例实战

4.1 找出所有 .java 文件（含子目录）

需求：键盘录入一个文件夹路径，找出这个文件夹下所有的 .java 文件（包括子文件夹）。 思路：单层用 listFiles() 即可，子文件夹需要<span style="color:green">递归</span>进入查找。

public static void findJava(File dir, ArrayList<String> list) {
    File[] files = dir.listFiles();
    if (files == null) return;

    for (File f : files) {
        if (f.isFile() && f.getName().endsWith(".java")) {
            list.add(f.getAbsolutePath());
        } else if (f.isDirectory()) {
            findJava(f, list);                 // 递归
        }
    }
}

4.2 递归删除文件夹

注意：delete() 只能删除空文件夹，所以要先删子再删自己（后序遍历）。

public static void deleteDir(File dir) {
    File[] files = dir.listFiles();
    if (files == null) return;

    for (File f : files) {
        if (f.isFile()) {
            f.delete();                       // 文件直接删
        } else if (f.isDirectory()) {
            deleteDir(f);                     // 递归
        }
    }
    dir.delete();                             // 最后删自己
}

4.3 递归统计文件夹大小

思路：文件夹 = 所有文件大小之和；遇到子文件夹继续递归。

public static long sizeOf(File dir) {
    long total = 0;
    File[] files = dir.listFiles();
    if (files == null) return 0;

    for (File f : files) {
        if (f.isFile()) {
            total += f.length();
        } else if (f.isDirectory()) {
            total += sizeOf(f);
        }
    }
    return total;
}

五、键盘录入路径案例

需求：键盘录入一个文件夹路径，如果输入错误就给出提示，并继续录入，直到正确为止。

分析：输入的路径可能不存在或是文件路径，所以需用 exists() + isDirectory() 双重判断。

Scanner sc = new Scanner(System.in);
File dir;
while (true) {
    System.out.print("请输入文件夹路径: ");
    String path = sc.nextLine();
    dir = new File(path);
    if (!dir.exists()) {
        System.out.println("路径不存在，请重新输入");
    } else if (!dir.isDirectory()) {
        System.out.println("不是文件夹，请重新输入");
    } else {
        break;
    }
}
System.out.println("已找到文件夹: " + dir.getAbsolutePath());

第十六章：常用 API

Java 提供了一系列"工具类"来完成数学计算、系统操作、日期处理等通用任务。本章覆盖 Math、System、包装类、BigDecimal、Arrays、Date、SimpleDateFormat、LocalDateTime / LocalDate / LocalTime、DateTimeFormatter 以及时间间隔工具 ChronoUnit / Duration / Period。

一、Math 类

Math 类是用于执行基本数字运算的工具类，所有方法都是 static 修饰，可直接通过类名调用。

二、System 类

System 的功能是静态的，都是直接用类名调用即可。

<span style="color:orange">时间原点小知识</span>：计算机中的时间原点是 1970 年 1 月 1 日 08:00:00。1969 年 8 月贝尔实验室的肯·汤普逊利用妻子离开一个月的机会开发了 Unix，使用 B 编译语言在 PDP-7 上开发，随后丹尼斯·里奇改进了 B 语言，开发出 C 语言重写了 Unix，因此 1970 年 1 月 1 日 也算 C 语言的生日。

三、包装类

Java 是面向对象的语言，但基本类型（如 int、double）不是对象，无法调用方法或参与泛型。包装类的作用就是将基本数据类型包装成类（变成引用数据类型），从而可以创建对象、调用方法解决问题。

<span style="color:red">⚠ 注意事项</span>：除了 int → Integer 和 char → Character 是"特殊拼写"外，其他都是基本类型首字母大写。

3.1 Integer 类

用于将基本数据类型手动包装为类。

<span style="color:orange">说明</span>：从 JDK9 开始 new Integer(int) 构造方法已被标记为过时，建议使用 valueOf 或自动装箱。

3.2 自动装箱与自动拆箱

Integer i = 10;        // 自动装箱
int n = i;             // 自动拆箱
int result = i + 100;  // 拆箱后参与运算

<span style="color:green">简单记</span>：有了自动拆装箱，基本数据类型和对应的包装类，可以直接运算，操作起来非常便捷。

3.3 包装类练习

需求：已知字符串 String s = "10,50,30,20,40"，请将该字符串转换为整数并存入数组，随后求出最大值打印在控制台。

String s = "10,50,30,20,40";
String[] arr = s.split(",");
int[] nums = new int[arr.length];
int max = nums[0];
for (int i = 0; i < arr.length; i++) {
    nums[i] = Integer.parseInt(arr[i]);   // 字符串 → int
    if (nums[i] > max) {
        max = nums[i];
    }
}
System.out.println("最大值: " + max);

四、BigDecimal 类

用于解决小数运算中出现的不精确问题。例如：

double num1 = 0.1;
double num2 = 0.2;
System.out.println(num1 + num2);   // 0.30000000000000004

4.1 创建对象

4.2 常用方法

4.3 divide 除法细节

除法运算需要注意除不尽的情况，必须指定保留位数与舍入模式。

BigDecimal divide = bd1.divide(参与运算的对象, 小数点后精确到多少位, 舍入模式);

BigDecimal a = new BigDecimal("10");
BigDecimal b = new BigDecimal("3");
BigDecimal r = a.divide(b, 2, RoundingMode.HALF_UP);  // 3.33

<span style="color:orange">小结</span>：BigDecimal 用于解决小数运算的精度损失问题；创建对象推荐 BigDecimal(String) 或 static valueOf(double)；除法运算要注意除不尽的情况。

五、Arrays 类

数组操作工具类，专门用于操作数组元素。

5.1 二分查找原理

二分查找的前提：必须是排好序的数据。每次取中间位置元素与目标值比较：

• 中间元素 < 目标值 → 往右半区查找
• 中间元素 > 目标值 → 往左半区查找
• 中间元素 = 目标值 → 找到

flowchart LR
  A["原始数组 11 22 33 44 55 66 77 88 99 100"] -->|"查找 88 中间=55 比 55 大，往右"| B["右半区 66 77 88 99 100"]
  B -->|"中间=88 正好相等"| C["找到索引 7"]

<span style="color:red">⚠ 注意</span>：如果查找的元素不在数组中，binarySearch 会返回负数（即 - (插入点 + 1)）。

int[] arr = {11, 22, 33, 44, 55, 66, 77, 88, 99, 100};
int idx = Arrays.binarySearch(arr, 88);   // 7

六、Date 类

Date 代表日期和时间，位于 java.util 包下。

Date d1 = new Date();
System.out.println(d1);                    // 当前时间
System.out.println(d1.getTime());          // 当前时间毫秒值
Date d2 = new Date(0L);                    // 时间原点
System.out.println(d2);                    // Thu Jan 01 08:00:00 CST 1970

<span style="color:orange">小结</span>：① Date 对象创建 → new Date()；② 获取时间毫秒值 → getTime()；③ 时间毫秒值转 Date 对象 → new Date(long time) 或 setTime(long time)。

七、SimpleDateFormat 类

用于日期格式化（Date → 字符串）和解析（字符串 → Date）。

7.1 构造器与格式化方法

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = new Date();
String s = sdf.format(d);                  // Date → 字符串
Date d2 = sdf.parse("2025-01-20 15:30:00"); // 字符串 → Date

<span style="color:orange">常用格式符号</span>：yyyy（年）MM（月）dd（日）HH（时）mm（分）ss（秒）。

八、JDK8 新增的时间 API

JDK8 之后新增的时间 API 设计更合理、功能丰富、使用方便，主要特点：

1. 都是不可变对象，修改后会返回新的时间对象，不会丢失最开始的时间
2. <span style="color:green">线程安全</span>
3. <span style="color:green">能精确到毫秒、纳秒</span>

8.1 LocalDateTime / LocalDate / LocalTime

获取对象：

获取年月日时分秒相关的方法：

修改年月日时分秒相关的方法：

LocalDateTime / LocalDate / LocalTime 都是不可变的，下列方法返回的是一个新的对象。

LocalDateTime ldt = LocalDateTime.now();
LocalDateTime newLdt = ldt
        .withHour(10)               // 修改小时
        .plusDays(7)                // 加 7 天
        .minusHours(2);             // 减 2 小时

8.2 DateTimeFormatter

用于时间的格式化和解析，是 JDK8 新增时间 API 的"格式器"。

DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime ldt = LocalDateTime.now();
String s = dtf.format(ldt);                     // 格式化
LocalDateTime ldt2 = LocalDateTime.parse(s, dtf); // 解析

九、时间间隔工具类

用于计算时间间隔，JDK8 提供了三个工具：

// 计算两个 LocalDateTime 之间相差的天、时、分
LocalDateTime start = LocalDateTime.of(2025, 1, 1, 0, 0, 0);
LocalDateTime end   = LocalDateTime.now();

long days  = ChronoUnit.DAYS.between(start, end);
long hours = ChronoUnit.HOURS.between(start, end);
long mins  = ChronoUnit.MINUTES.between(start, end);

<span style="color:orange">案例</span>：根据用户填写的生日计算年龄——使用 Period.between(birth, today) 取得"年、月、日"三段间隔，进而精确计算周岁。

LocalDate birth = LocalDate.of(1990, 12, 1);
LocalDate today = LocalDate.now();
Period p = Period.between(birth, today);
System.out.println("年龄：" + p.getYears() + " 岁 "
        + p.getMonths() + " 月 " + p.getDays() + " 天");

第十七章：IO 流

IO 是 "Input / Output" 的缩写，意为输入 / 输出，本质是数据传输。常见场景：读写配置文件 / 日志文件、客户端与服务端通讯、文件上传下载等。

一、IO 介绍和分类

1.1 IO 流向

把外存中的数据读取到内存中称为"输入"（读），把内存中的数据写出到外存中称为"输出"（写）。

flowchart LR
  subgraph 输入流管道
    direction LR
    FILE["D:\user.txt"] -->|"读取数据"| JVM["Java 程序"]
  end
  subgraph 输出流管道
    direction RL
    FILE2["D:\user.txt"] <==|"写出数据"| JVM2["Java 程序"]
  end

1.2 IO 流体系结构

IO 流按"数据单位"分为两大体系：字节流（万能流，所有文件都能操作）和字符流（纯文本文件专用，能解决中文乱码）。

<span style="color:orange">小结</span>：字符流使用场景：读写纯文本文件；字节流使用场景：不是纯文本文件都用字节流。

二、FileOutputStream 字节输出流

FileOutputStream 是字节输出流的子类，用于把 Java 程序的数据写出到文件（如 D:\A.txt）。

2.1 构造方法

<span style="color:red">⚠ 注意事项</span>：① 关联的文件如果不存在会自动创建；② 如果文件已存在，默认会<span style="color:red">清空原有的内容</span>再重新写入（除非开启追加模式）。

2.2 成员方法

// 示例：写出数据
FileOutputStream fos = new FileOutputStream("D:\\A.txt", true);  // 追加写入
fos.write(97);                      // 写出单个字节 'a'
fos.write("Hello".getBytes());      // 写出整个字符串
fos.close();                        // 关闭流，释放资源

三、关流与异常处理

流对象使用完毕后，<span style="color:red">记得调用 close 方法关闭，不然会占用资源</span>。

3.1 JDK7 之后的 try-with-resources 写法

try 后面的小括号里可以直接写需要关闭的对象，前提是该对象实现了 AutoCloseable 接口。

try (FileOutputStream fos = new FileOutputStream("D:\\A.txt")) {
    fos.write("Hello".getBytes());
} catch (IOException e) {
    e.printStackTrace();
}

<span style="color:green">优势</span>：① 自动调用 close() 释放资源；② 代码更简洁，避免忘记关流。

四、FileInputStream 字节输入流

FileInputStream 是字节输入流，用于读取文件中的数据到 Java 程序（如把 D:\A.txt 的内容读进来）。

4.1 构造方法

<span style="color:red">⚠ 注意事项</span>：① 关联的文件不存在会抛出 FileNotFoundException 异常；② 文件夹的话会拒绝访问。

4.2 成员方法

// 方式一：单字节读取（效率低）
try (FileInputStream fis = new FileInputStream("D:\\A.txt")) {
    int b;
    while ((b = fis.read()) != -1) {
        System.out.print((char) b);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 方式二：字节数组读取（推荐，效率高）
try (FileInputStream fis = new FileInputStream("D:\\A.txt")) {
    byte[] bys = new byte[2];
    int len;
    while ((len = fis.read(bys)) != -1) {
        System.out.print(new String(bys, 0, len));
    }
} catch (IOException e) {
    e.printStackTrace();
}

4.3 String 构造方法（配合使用）

五、文件拷贝案例

需求：将 D:\嘿嘿.jpg 拷贝到 E:\ 根目录下。

flowchart LR
  A["1. 创建输入流对象 读取文件"] --> B["2. 创建输出流对象 关联数据目的"]
  B --> C["3. 读写操作"]
  C --> D["4. 关流释放资源"]

try (
    FileInputStream fis = new FileInputStream("D:\\嘿嘿.jpg");
    FileOutputStream fos = new FileOutputStream("E:\\嘿嘿.jpg")
) {
    byte[] bys = new byte[1024];
    int len;
    while ((len = fis.read(bys)) != -1) {
        fos.write(bys, 0, len);
    }
} catch (IOException e) {
    e.printStackTrace();
}

六、FileReader 字符输入流

用于读取纯文本文件，能解决中文乱码问题。

七、FileWriter 字符输出流

7.1 构造方法

7.2 成员方法

<span style="color:red">⚠ 注意事项</span>：字符输出流写出数据，需要调用 flush 或 close 方法，数据才会写出。

• flush() 后可以继续写出
• close() 后不能继续写出（流已关闭）

八、Properties 集合

Properties 是 java.util 包下的类，<span style="color:blue">继承自 Hashtable<Object, Object>，本质是一个 Map 集合</span>，但键和值都必须是 String。

8.1 作为集合使用

Properties prop = new Properties();
prop.setProperty("username", "admin");
prop.setProperty("password", "123456");
System.out.println(prop.getProperty("username"));  // admin

8.2 和 IO 有关的方法

// 把集合中的键值对写到配置文件
Properties prop = new Properties();
prop.setProperty("username", "admin");
prop.setProperty("password", "123456");
try (FileWriter fw = new FileWriter("config.properties")) {
    prop.store(fw, "user config");
}

// 从配置文件中读取键值对到集合
Properties prop2 = new Properties();
try (FileReader fr = new FileReader("config.properties")) {
    prop2.load(fr);
    System.out.println(prop2.getProperty("username"));
}

<span style="color:orange">小结</span>：① Properties 本质就是 Map 集合，键值都是 String；② setProperty(键,值) 添加、getProperty(键) 取值；③ load 从流加载、store 写入流——将来加载配置文件时很方便。

九、HuTool 工具

9.1 Hutool 介绍

Hutool 是一个小而全的 Java 工具类库，通过静态方法封装，降低相关 API 的学习成本，提高工作效率。

• 名称由来：Hutool = Hu + tool，是原公司项目底层代码剥离后的开源库，"Hu" 是公司名称的表示，tool 表示工具
• 谐音"糊涂"，一方面简洁易用，一方面寓意"难得糊涂"

9.2 Hutool 常用 API

Hutool 不是 JDK 自带的，使用时需要导入 jar 包（后续学习 Maven 可简化此操作）。

IoUtil 类提供的部分方法：

FileUtil 类提供的部分方法：

<span style="color:orange">Tips</span>：Hutool 导入 jar 包的方式较为繁琐，<span style="color:green">后面学到 Maven 的时候可以简化</span>。

第十八章：多线程

多线程是 Java 编程中非常重要的特性，用于提高程序执行效率和同时处理多个任务。本章从进程和线程的概念讲起，逐步深入到 Java 线程的创建、线程安全、线程同步以及线程池的使用。

一、进程和线程

1.1 进程介绍

进程（Process） 是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配的基本单位。简单理解为程序的执行过程。

进程的特点：

<span style="color:orange">小结</span>：进程是程序的执行过程，具有独立性、动态性、并发性。对于一个 CPU 而言，它是在多个进程间轮换执行的。

1.2 并行和并发

并行：在同一时刻，有多个指令在多个 CPU 上<span style="color:green">同时</span>执行。 并发：在同一时刻，有多个指令在单个 CPU 上<span style="color:orange">交替</span>执行。

flowchart LR
  subgraph 并行
    direction LR
    A["CPU 1"] --> A1["任务 1"]
    B["CPU 2"] --> B1["任务 2"]
  end
  subgraph 并发
    direction LR
    C["单个 CPU"] --> C1["任务 1"]
    C1 -.-> C2["任务 2"]
    C2 -.-> C1
  end

1.3 线程介绍

线程（Thread）：进程可以同时执行多个任务，<span style="color:green">每个任务就是一个线程</span>。例如：360 安全卫士中的"电脑清理"和"电脑杀毒"是同一个进程中的不同线程。

flowchart TB
  P["进程"] --> T1["子任务 1（单线程）"]
  P --> T2["子任务 2（多线程）"]
  T1 --> S1["子任务 1"]
  S1 --> S2["子任务 2"]
  T2 --> S3["子任务 1"]
  T2 --> S4["子任务 2"]

1.4 多线程的意义

随着处理器上的核心数量越来越多，现在大多数计算机都比以往更加擅长并行计算。一个线程，在一个时刻，只能运行在一个处理器核心上。

多线程的两个核心作用：

<span style="color:orange">小结</span>：线程是进程中的任务，<span style="color:green">多线程就是多个任务</span>。多线程的意义在于提高效率、可以同时处理多个任务。

二、Java 开启线程的方式

Java 中有三种方式可以开启线程：<span style="color:green">继承 Thread 类</span>、<span style="color:green">实现 Runnable 接口</span>、<span style="color:green">实现 Callable 接口</span>。<span style="color:red">推荐后两种方式</span>，因为它们扩展性更好（避免了单继承的局限性）。

三、线程相关方法

3.1 常用方法

Thread 类提供了丰富的线程控制方法，红色标记的是静态方法。

// 示例：获取并设置线程名
MyThread t1 = new MyThread("线程A");
MyThread t2 = new MyThread("线程B");

t1.setName("高铁");
t2.setName("飞机");

System.out.println(t1.getName());  // 高铁
System.out.println(t2.getName());  // 飞机

// Thread.currentThread()：获取当前线程对象
System.out.println(Thread.currentThread().getName());  // main

3.2 线程调度方式

Java 线程调度采用抢占式调度（线程优先级高的先获取 CPU 资源），但结果随机（因为多线程有随机性）。

<span style="color:orange">优先级范围</span>：<span style="color:red">1 ~ 10</span>，<span style="color:blue">默认值为 5</span>。优先级高只是获取 CPU 资源的概率高，不是绝对先执行。

MyThread t1 = new MyThread("高铁");
MyThread t2 = new MyThread("飞机");

t1.setPriority(Thread.MIN_PRIORITY);  // 1
t2.setPriority(Thread.MAX_PRIORITY);  // 10

System.out.println(t1.getPriority());  // 1
System.out.println(t2.getPriority());  // 10

四、线程安全和同步

4.1 线程安全的问题

需求：某电影院目前正在上映国产大片，共有 100 张票，而它有 3 个窗口卖票。请设计一个程序模拟该电影院卖票。

class Tickets implements Runnable {
    int tickets = 1;

    @Override
    public void run() {
        while (true) {
            if (tickets <= 0) {
                break;
            }
            System.out.println(Thread.currentThread().getName() + "卖出了第" + tickets + "号票");
            tickets--;
        }
    }
}

上面的代码存在线程安全问题：多个线程同时操作共享数据 tickets，可能导致卖出同一张票甚至卖出 0 号、-1 号票。

4.2 线程安全问题分析

三个线程同时进入 while 循环，都读取到 tickets = 1，于是都"卖出了第 1 号票"，然后 tickets-- 多次，结果出现重复卖票或卖出非法票号。

安全问题出现的条件：

4.3 线程同步

同步技术：将多条语句操作共享数据的代码<span style="color:green">锁</span>起来，让任意时刻只能有一个线程可以执行。

flowchart TB
  subgraph 同步前
    direction TB
    T1["线程 1"] -->|"进入"| Code["多条语句操作共享数据"]
    T2["线程 2"] -->|"进入"| Code
    T3["线程 3"] -->|"进入"| Code
  end
  subgraph 同步后
    direction TB
    T1A["线程 1"] -->|"加锁"| LockA["🔒 锁"]
    LockA -->|"执行"| CodeA["多条语句操作共享数据"]
    T2A["线程 2"] -.等待.-> LockA
    T3A["线程 3"] -.等待.-> LockA
  end

Java 提供三种同步方式：

4.3.1 同步代码块

synchronized(锁对象) {
    多条语句操作共享数据的代码
}

<span style="color:red">⚠ 注意事项</span>：

• 锁对象可以是任意对象，但是需要保证多条线程的锁对象，<span style="color:red">是同一把锁</span>
• 同步可以解决多线程的数据安全问题，但是<span style="color:orange">也会降低程序的运行效率</span>

class Tickets implements Runnable {
    int tickets = 100;
    Object lock = new Object();  // 锁对象

    @Override
    public void run() {
        while (true) {
            synchronized (lock) {
                if (tickets <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖出了第" + tickets + "号票");
                tickets--;
            }
        }
    }
}

4.3.2 同步方法

在方法的返回值类型前面加入 synchronized 关键字。

public synchronized void method() {
    // 多条语句操作共享数据的代码
}

<span style="color:orange">小细节</span>：

• 方法分为静态和非静态
• <span style="color:blue">静态方法</span>的锁对象是字节码对象（类名.class）
• <span style="color:green">非静态方法</span>的锁对象是 this

4.3.3 Lock 锁

使用 Lock 锁，我们可以<span style="color:green">更清晰</span>地看到哪里加了锁，哪里释放了锁。相比 synchronized，Lock 锁更灵活、性能更好。

对比：

// 方式一：同步代码块
synchronized(锁对象) {
    多条语句操作共享数据的代码
}

// 方式二：同步方法
public synchronized void method() { }

// 方式三：Lock 锁
lock.lock();
...
lock.unlock();

Lock 是接口，无法直接创建对象。

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Lock;

class Tickets implements Runnable {
    int tickets = 100;
    Lock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (tickets <= 0) {
                    break;
                }
                System.out.println(Thread.currentThread().getName() + "卖出了第" + tickets + "号票");
                tickets--;
            } finally {
                lock.unlock();  // 无论是否异常，都需要释放锁
            }
        }
    }
}

五、线程池介绍

5.1 线程池的好处

池：提前创建好的一组资源（如数据库连接池、常量池）。<span style="color:green">将线程对象交给线程池维护</span>，可以降低系统成本，从而提升程序的性能。

为什么需要线程池：

5.2 线程池学习路径

学习线程池分三步：理解线程池的好处 → 使用 JDK 提供的线程池 → 自定义线程池。

flowchart LR
  A["理解线程池的好处"] --> B["使用 JDK 提供的线程池"]
  B --> C["自定义线程池"]

<span style="color:red">⚠【强制】</span>线程池不允许使用 Executors 去创建，而是通过 ThreadPoolExecutor 的方式，这样的处理方式让写的同学更加明确线程池的运行规则，规避资源耗尽的风险。

说明：Executors 返回的线程池对象的弊端如下：

1. FixedThreadPool 和 SingleThreadPool：允许的请求队列长度为 Integer.MAX_VALUE，<span style="color:red">可能会堆积大量的请求</span>，从而导致 OOM。
2. CachedThreadPool：允许的创建线程数量为 Integer.MAX_VALUE，<span style="color:red">可能会创建大量的线程</span>，从而导致 OOM。

5.3 使用 JDK 提供的线程池

Executors 中提供静态方法来创建线程池（<span style="color:orange">了解即可，实际开发推荐使用 ThreadPoolExecutor</span>）。

六、自定义线程池

6.1 ThreadPoolExecutor 类

ThreadPoolExecutor 是线程池的核心实现类，其构造方法有 7 个参数。

ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit,
                   BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)

6.2 参数详解

flowchart TB
  Customers["顾客队列"] -->|"新任务"| Core["核心线程（正式员工） 数 = corePoolSize"]
  Core -->|"核心线程满"| Queue["任务队列 BlockingQueue"]
  Queue -->|"队列满"| Temp["临时线程 (maximumPoolSize - corePoolSize)"]
  Temp -->|"全部忙 + 队列满"| Reject["拒绝策略 RejectedExecutionHandler"]
  Temp -->|"空闲 keepAliveTime"| Temp
  Core -->|"空闲 keepAliveTime"| Core

6.3 线程池拒绝策略

6.4 自定义线程池小结

<span style="color:orange">思考</span>：临时线程什么时候创建？什么时候会开启拒绝策略？

flowchart TB
  T["提交新任务"] --> Q1{"核心线程 是否已满？"}
  Q1 -->|"否"| C1["创建核心线程执行"]
  Q1 -->|"是"| Q2{"任务队列 是否已满？"}
  Q2 -->|"否"| Q3["任务进入队列等待"]
  Q2 -->|"是"| Q4{"当前线程数 是否达到最大？"}
  Q4 -->|"否"| C2["创建临时线程执行"]
  Q4 -->|"是"| Q5["执行拒绝策略"]

<span style="color:orange">小结</span>：自定义线程池通过 ThreadPoolExecutor 的 7 个参数灵活控制线程池的行为。核心线程处理正常业务，任务队列起到缓冲作用，临时线程应对突发流量，拒绝策略保证系统在极端情况下不会崩溃。

第十九章：网络编程

网络编程是实现设备间数据通信的核心技术，本章从通信架构、网络三要素讲起，重点掌握 <span style="color:green">UDP</span> 和 <span style="color:green">TCP</span> 两种协议的数据收发方式。

一、网络编程基本概念

1.1 网络编程

网络编程是让设备中的程序与网络上其他设备中的程序进行数据交互的技术（实现<span style="color:green">网络通信</span>）。典型场景：手机与手机聊天、网页访问服务器。

1.2 基本的通信架构

基本的通信架构有 2 种形式：<span style="color:green">CS 架构</span>、<span style="color:green">BS 架构</span>。

<span style="color:orange">⚠</span> 无论是 CS 架构，还是 BS 架构的软件都<span style="color:red">必须依赖网络编程</span>！Java 提供了哪些网络编程解决方案？java.net.* 包下提供了网络编程的解决方案！

flowchart LR
  subgraph CS架构
    direction LR
    A1["Client 客户端"] -->|"请求"| B1["Server 服务端"]
    B1 -->|"响应"| A1
  end
  subgraph BS架构
    direction LR
    A2["Browser 浏览器"] -->|"HTTP请求"| B2["Server 服务端"]
    B2 -->|"HTTP响应"| A2
  end

二、网络编程三要素

网络通信三要素：<span style="color:red">IP 地址</span>、<span style="color:orange">端口</span>、<span style="color:green">协议</span>。

2.1 IP 地址

IP（Internet Protocol）：全称"互联网协议地址"，是分配给上网设备的唯一标识。目前，被广泛采用的 IP 地址形式有两种：<span style="color:green">IPv4</span>、<span style="color:green">IPv6</span>。

<span style="color:orange">小细节</span>：IPv4 地址一般写成 11000000.10101000.00000001.01000010，转成十进制就是 192.168.1.66。

2.1.1 IPv4 地址的分类形式

<span style="color:orange">小结</span>：常见场景为网吧、公寓、商场、办公楼等小型组织内部使用 <span style="color:green">192.168.xxx.xxx</span> 的私有地址。

2.1.2 特殊 IP 地址

127.0.0.1（也可以是 localhost）：是回送地址也称本地回环地址，也称本机 IP，永远只会寻找当前所在本机。 <span style="color:orange">建议</span>：自己练习就写 127.0.0.1。

flowchart LR
  A["你的电脑"] -->|"访问其他电脑"| B["192.168.1.10"]
  A -->|"访问自己"| C["127.0.0.1"]

2.1.3 IP 和域名

平时上网没有用过 IP，都是用网址的。浏览器访问服务器时，先通过 DNS 服务器把网址（域名）解析成 IP 地址，再去访问对应的服务器。

flowchart LR
  Browser["浏览器"] -->|"网址/域名"| DNS["DNS 服务器"]
  DNS -->|"IP 地址"| Browser
  Browser -->|"访问黑马程序员服务器"| Server["黑马程序员服务器"]
  Server -->|"返回数据"| Browser

2.1.4 常用的 CMD 命令

<span style="color:orange">小结</span>：

• 现在如何解决 IPv4 不够的问题？ <span style="color:green">利用局域网 IP 解决 IP 不够的问题</span>
• 特殊的 IP 是什么？ 127.0.0.1（永远表示本机）
• 常见的两个 CMD 命令？ ipconfig、ping

2.1.5 InetAddress 类

为了方便对 IP 地址的获取和操作，Java 提供了 InetAddress 类。 InetAddress：此类表示 Internet 协议（IP）地址。

import java.net.InetAddress;

public class InetAddressDemo {
    public static void main(String[] args) throws Exception {
        InetAddress address = InetAddress.getByName("DESKTOP-ABC123");
        // InetAddress address = InetAddress.getByName("192.168.1.100");

        System.out.println(address.getHostName());   // 主机名
        System.out.println(address.getHostAddress()); // IP 地址字符串
    }
}

2.2 端口号

端口号是应用程序在设备中唯一的标识。

<span style="color:red">⚠ 注意</span>：一个端口号只能被一个应用程序使用。

flowchart LR
  subgraph 电脑A
    APP1["WeChat 6666"] --> P65533["65533 消息"]
    APP2["QQ 7777"] --> P65533
    APP3["Game 8888"] --> P65533
  end
  P65533 -->|"端口号"| 电脑B

2.3 协议

计算机网络中，连接和通信的规则被称为网络通信协议。常见的协议有 <span style="color:green">UDP 协议</span> 和 <span style="color:green">TCP 协议</span>。

2.3.1 UDP 协议

用户数据报协议（User Datagram Protocol）。

• <span style="color:green">面向无连接</span>的通信协议
• 速度快，有大小限制（<span style="color:red">一次最多发送 64K</span>）
• 数据不安全，易丢失数据
• 不管是否已经连接成功，都会发送
• <span style="color:green">典型应用</span>：在线视频

2.3.2 TCP 协议

传输控制协议 TCP（Transmission Control Protocol）。

• <span style="color:green">面向连接</span>的通信协议
• 速度慢，没有大小限制，数据安全
• 通过<span style="color:red">三次握手</span>建立连接
• 通过<span style="color:red">四次挥手</span>断开连接
• <span style="color:green">典型应用</span>：下载软件

flowchart LR
  subgraph 三次握手
    direction TB
    A1["客户端"] -->|"① 连接请求"| B1["服务器"]
    B1 -->|"② 响应"| A1
    A1 -->|"③ 确认"| B1
  end
  subgraph 四次挥手
    direction TB
    A2["客户端"] -->|"① 取消请求"| B2["服务器"]
    B2 -->|"② 响应"| A2
    B2 -->|"③ 处理数据后确认"| A2
    A2 -->|"④ 确认"| B2
  end

<span style="color:orange">小结</span>：网络通信三要素是 IP 地址、端口、协议，<span style="color:green">三者缺一不可</span>。

三、UDP 协议收发数据

3.1 UDP 协议发送数据

类比快递流程：① 找快递公司 → ② 打包礼物 → ③ 快递公司发送包裹 → ④ 付钱走人。

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPSend {
    public static void main(String[] args) throws Exception {
        // ① 创建发送端的 DatagramSocket 对象
        DatagramSocket ds = new DatagramSocket();

        // ② 打包礼物（数据）
        String msg = "你好 UDP";
        byte[] bytes = msg.getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 10086;

        DatagramPacket dp = new DatagramPacket(bytes, bytes.length, address, port);

        // ③ 发送数据
        ds.send(dp);

        // ④ 释放资源
        ds.close();
    }
}

3.2 UDP 协议接收数据

类比快递流程：① 找快递公司 → ② 接收箱子 → ③ 从箱子里面获取礼物 → ④ 签收走人。

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UDPReceive {
    public static void main(String[] args) throws Exception {
        // ① 创建接收端的 DatagramSocket 对象
        // 必须指定端口号，跟发送端一致
        DatagramSocket ds = new DatagramSocket(10086);

        // ② 接收打包好的数据
        byte[] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes, bytes.length);

        // 该方法是阻塞的，会一直等发送端发送数据
        ds.receive(dp);

        // ③ 解析数据包
        byte[] data = dp.getData();
        int len = dp.getLength();
        String msg = new String(data, 0, len);
        System.out.println("数据是：" + msg);

        // ④ 释放资源
        ds.close();
    }
}

<span style="color:orange">小结</span>：UDP 协议收发数据

• 使用 DatagramSocket 搭建站点
• 使用 DatagramPacket 打包数据
• send 方法用于发送
• receive 方法用于接收

四、TCP 协议收发数据

4.1 TCP 通信程序

TCP 通信严格区分<span style="color:green">客户端</span>和<span style="color:green">服务端</span>。

4.1.1 客户端

<span style="color:orange">提示</span>：这里的流对象不是读写文件中的数据

• <span style="color:green">输出流</span>：写出数据到服务端
• <span style="color:green">输入流</span>：读取服务端发送过来的数据

4.1.2 服务端

// ================ 客户端 ================
import java.io.OutputStream;
import java.net.Socket;

public class TCPClient {
    public static void main(String[] args) throws Exception {
        // 1. 创建 Socket 对象指定 IP 和端口
        Socket socket = new Socket("127.0.0.1", 10086);

        // 2. 通过 socket 对象获取输出流
        OutputStream os = socket.getOutputStream();

        // 3. 写出数据
        os.write("你好 TCP".getBytes());

        // 4. 释放资源
        os.close();
        socket.close();
    }
}

// ================ 服务端 ================
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPServer {
    public static void main(String[] args) throws Exception {
        // 1. 创建 ServerSocket 对象指定端口
        ServerSocket ss = new ServerSocket(10086);

        // 2. 响应客户端发送的请求，得到 Socket 对象
        Socket socket = ss.accept();

        // 3. 通过 socket 对象获取输入流
        InputStream is = socket.getInputStream();

        // 4. 读取数据
        byte[] bytes = new byte[1024];
        int len = is.read(bytes);
        String msg = new String(bytes, 0, len);
        System.out.println("客户端发来：" + msg);

        // 5. 释放资源
        is.close();
        socket.close();
        ss.close();
    }
}

<span style="color:orange">小结</span>：TCP 协议区分客户端和服务端

• 客户端创建 Socket 对象，指定 IP 和端口号
• 服务端创建 ServerSocket 对象，指定端口号
• 调用 accept() 响应请求，得到 Socket 对象
• 两端通过 Socket 对象获取输入输出流，收发数据

第二十章：Java 高级技术

本章是 Java 高级特性的综合章节，涵盖枚举、类加载器、反射、注解、动态代理等核心技术。这些技术是框架的基石，掌握它们可以更深入地理解框架的运行原理。

一、枚举

1.1 枚举介绍

枚举是 Java 中的一种特殊类型，一般用来做信息的标记和分类。例如用标记来区分春、夏、秋、冬四个季节。

传统方式 vs 枚举方式：

// 传统方式：使用 public static final 常量
class Season {
    public static final int SPRING = 1;
    public static final int SUMMER = 2;
    public static final int AUTUMN = 3;
    public static final int WINTER = 4;
}

// 枚举方式：使用 enum 关键字
enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

1.2 枚举定义格式

<span style="color:green">枚举本质上是一个类</span>，但比类多了几个特殊限制。

修饰符 enum 枚举类名 {
    枚举项1, 枚举项2, 枚举项3...;
}

public enum Season {
    SPRING, SUMMER, AUTUMN, WINTER;
}

1.3 枚举的特点

1.4 枚举的使用场景

枚举最适合用于做信息的标记和分类。

场景：商品状态有 在售/预售/售罄 三种情况。

// 传统方式：定义多个常量
public static final int PRE_SALE = 1;  // 预售
public static final int SALE = 2;      // 在售
public static final int SELLOUT = 3;   // 售罄

// 枚举方式：一目了然
enum GoodState {
    PRE_SALE,   // 预售
    SALE,       // 在售
    SELLOUT     // 售罄
}

<span style="color:orange">小结</span>：使用枚举做信息的标记和分类，<span style="color:green">代码可读性更高</span>，<span style="color:green">入参约束严谨</span>，<span style="color:green">代码优雅</span>。

二、类加载器

2.1 类加载器介绍

类加载器负责将类的字节码载入方法区中。加载时机为：<span style="color:green">用到就加载</span>。

flowchart LR
  A[Java 源文件] -->|javac 编译| B[class 字节码文件]
  B -->|类加载器载入| C[方法区]

加载时机（满足以下任一条件即可）：

2.2 类加载器的加载过程

类的加载过程分三步：<span style="color:purple">加载</span> → <span style="color:red">链接</span>（验证、准备、解析） → <span style="color:blue">初始化</span>。

flowchart LR
  A[加载] -->|找到 class| B[链接]
  B --> C[验证]
  C --> D[准备]
  D --> E[解析]
  E --> F[初始化]

<span style="color:orange">小工具</span>：jps 是 JDK 提供的一个查看当前 Java 进程的小工具。HSDB（Hotspot Debugger）是一款内置于 SA 中的 GUI 调试工具，可用于调试 JVM 运行时数据。启动命令：

java -cp ./lib/sa-jdi.jar sun.jvm.hotspot.HSDB

2.3 类加载器的分类

获取类加载器：

2.4 双亲委派模式

双亲委派模式是 Java 类加载器的核心机制。

flowchart TB
  Start["开始 AppClassLoader"] --> A1{"是否加载过?"}
  A1 -->|是| Loaded["已经加载过 不再加载"]
  A1 -->|否| A2{"是否可以加载?"}
  A2 -->|否| P1["向上委托 PlatformClassLoader"]
  A2 -->|是| Done["自己加载此类"]
  P1 --> P2{"是否加载过?"}
  P2 -->|是| Loaded
  P2 -->|否| P3{"是否可以加载?"}
  P3 -->|否| B1["向上委托 BootStrapClassLoader"]
  P3 -->|是| Done
  B1 --> B2{"是否加载过?"}
  B2 -->|是| Loaded
  B2 -->|否| B3{"是否可以加载?"}
  B3 -->|否| CNF["ClassNotFoundException"]
  B3 -->|是| Done

双亲委派模式的原则：

1. 如果一个类加载器收到了类加载请求，<span style="color:green">它并不会自己先去加载</span>
2. 而是把这个请求<span style="color:green">委托给父类的加载器</span>去执行
3. 如果父类加载器还存在其父类加载器，则进一步向上委托，<span style="color:green">依次递归</span>
4. 请求最终将到达<span style="color:red">顶层的启动类加载器</span>
5. 如果父类加载器可以完成类加载任务，就<span style="color:green">成功返回</span>
6. 倘若父类加载器无法完成此加载任务，<span style="color:green">子加载器才会尝试自己去加载</span>，这就是双亲委派模式
7. <span style="color:green">避免类的重复加载</span>

<span style="color:orange">小结</span>：

• 类加载器负责将类的字节码载入到方法区中
• 加载时机：用到就加载
• 加载过程：<span style="color:purple">加载</span> → <span style="color:red">链接（验证、准备、解析）</span> → <span style="color:blue">初始化</span>

三、反射

3.1 反射介绍

反射是框架技术的灵魂。反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意属性和方法。这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制。

<span style="color:orange">理解</span>：注释是给人看的，<span style="color:green">注解是给虚拟机看的</span>。反射操作的是<span style="color:green">字节码对象</span>。

flowchart LR
  Byte["字节码对象"] -->|"解剖"| A1["构造方法对象"]
  Byte --> A2["成员变量对象"]
  Byte --> A3["成员方法对象"]
  A1 -->|"创建"| A1a["创建对象"]
  A2 -->|"赋值、获取"| A2a["赋值 获取"]
  A3 -->|"调用"| A3a["调用"]

3.2 反射技术的学习路径

1. <span style="color:green">获取类的字节码对象</span>
2. 反射类中的构造方法，随后创建对象
3. 反射类中的成员变量，完成赋值和获取
4. 反射类中的成员方法，调用成员方法

3.3 获取类的字节码对象

获取 Class 对象有<span style="color:green">三种方式</span>。

// 1. Class.forName（最常用）
Class<?> clazz1 = Class.forName("com.itheima.Student");

// 2. 类名.class
Class<?> clazz2 = Student.class;

// 3. 对象.getClass()
Student stu = new Student();
Class<?> clazz3 = stu.getClass();

<span style="color:orange">小结</span>：反射是框架技术的灵魂，在运行状态中可以操作任意类中的任意属性任意方法；反射操作的是字节码对象；获取字节码对象的三种方式见上表。

3.4 反射类中的构造方法

Constructor 类用于创建对象的方法：

// 通过反射获取无参构造方法并创建对象
Class<?> clazz = Class.forName("com.itheima.Student");
Constructor<?> con = clazz.getDeclaredConstructor();
con.setAccessible(true);  // 取消访问检查
Object obj = con.newInstance();

<span style="color:red">⚠ 反射建议</span>：<span style="color:red">禁止暴力反射操作</span>（生产环境慎用 setAccessible(true)）。

3.5 反射类中的成员变量

Field 类的设置和获取方法：

Class<?> clazz = Class.forName("com.itheima.Student");
Object obj = clazz.getDeclaredConstructor().newInstance();

// 反射获取 name 成员变量并赋值
Field nameField = clazz.getDeclaredField("name");
nameField.setAccessible(true);
nameField.set(obj, "张三");
String name = (String) nameField.get(obj);
System.out.println(name);  // 张三

3.6 反射类中的成员方法

Method 类用于执行方法的方法：

Class<?> clazz = Class.forName("com.itheima.Student");
Object obj = clazz.getDeclaredConstructor().newInstance();

// 反射调用 study 方法
Method method = clazz.getDeclaredMethod("study");
method.setAccessible(true);
method.invoke(obj);  // 调用 study()

3.7 反射练习

练习 1（伪泛型）：请向一个泛型为 Integer 的集合，添加一个 String 字符串。 <span style="color:orange">思路</span>：Java 中的泛型是假的，只在编译的时候有效。

ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);

// 通过反射绕过泛型检查
Class<?> clazz = list.getClass();
Method add = clazz.getMethod("add", Object.class);
add.invoke(list, "hello");

System.out.println(list);  // [1, 2, hello]

练习 2（配置文件 + 反射）：编写 Student/Teacher/Worker 三个 JavaBean（属性均为 name、age），通过修改配置文件实现不修改代码切换调用不同类的不同方法。

# config.properties
className=com.itheima.Student
methodName=study

public class ReflectDemo {
    public static void main(String[] args) throws Exception {
        // 1. 读取配置文件
        Properties prop = new Properties();
        prop.load(new FileInputStream("config.properties"));
        String className = prop.getProperty("className");
        String methodName = prop.getProperty("methodName");

        // 2. 通过反射创建对象
        Class<?> clazz = Class.forName(className);
        Constructor<?> con = clazz.getDeclaredConstructor();
        Object obj = con.newInstance();

        // 3. 通过反射调用方法
        Method method = clazz.getDeclaredMethod(methodName);
        method.invoke(obj);
    }
}

四、注解

4.1 注解介绍

Annotation 表示注解，是 <span style="color:red">JDK 1.5</span> 的新特性。注解的主要作用是<span style="color:green">对程序进行标注</span>。

<span style="color:orange">理解</span>：

• 注释是给人看的，<span style="color:green">注解是给虚拟机看的</span>
• 通过注解可以给类增加额外的信息
• 编译器或 JVM 可以根据注解来完成对应的功能

JDK 中常见注解：

4.2 自定义注解

<span style="color:orange">重要</span>：自定义注解<span style="color:red">单独存在意义不大</span>，一般会跟<span style="color:green">反射结合起来</span>使用。

4.2.1 自定义注解格式

public @interface 注解名称 {
    public 属性类型 属性名() default 默认值;
}

public @interface Anno {
    String show() default "show...";
}

属性类型：

完整示例：

public @interface MyAnno {
    public static final int num1 = 100;
    public static final String num2 = "abc";
    public static final MyAnno num3 = null;
    public static final Class num4 = String.class;
    public static final int[] num5 = {};

    public abstract String show1() default "show1";
    public abstract int show2() default 132;
    public abstract MyAnno2 show3() default @MyAnno2;
    public abstract Class show4() default String.class;
    public abstract int[] show5() default {1, 2, 3};
}

4.2.2 自定义注解使用

常用位置：

1. <span style="color:green">类</span>
2. <span style="color:green">方法</span>

<span style="color:red">⚠ 注意</span>：

• 在使用注解时，如果注解的属性没有给出默认值，<span style="color:green">需要手动给出</span>
• @Anno(name="张三")
• 如果数组中只有一个属性值，在使用时 <span style="color:green">{} 是可以省略的</span>

4.2.3 特殊的属性 value

如果只有一个属性名字为 value 没有赋值，使用时<span style="color:green">直接给出值</span>，不需要写属性名。

public @interface SuppressWarnings {
    String[] value();
}

// 简化写法
@SuppressWarnings("all")
public class MyClass { }

4.3 元注解

元注解就是用在<span style="color:green">注解上</span>的注解。

4.3.1 @Target

@Target：用来标识注解使用的位置，如果没有使用该注解标识，则自定义的注解可以使用在任意位置。

@Target 可使用的值定义在 ElementType 枚举类中：

4.3.2 @Retention

@Retention：用来标识注解的生命周期（有效范围）。

@Retention 可使用的值定义在 RetentionPolicy 枚举类中：

自定义测试注解案例：

需求：自定义一个注解 @Test，用于指定类的方法上，如果类中的某个方法上使用了该注解，就执行该方法。

// 1. 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Test {
}

// 2. 使用注解
public class UserTest {
    @Test
    public void test1() { System.out.println("test1 执行了"); }

    public void test2() { System.out.println("test2 没执行"); }
}

// 3. 通过反射执行
public static void main(String[] args) throws Exception {
    Class<?> clazz = UserTest.class;
    Object obj = clazz.getDeclaredConstructor().newInstance();
    for (Method method : clazz.getDeclaredMethods()) {
        if (method.isAnnotationPresent(Test.class)) {
            method.invoke(obj);
        }
    }
}

五、动态代理

5.1 动态代理

动态代理是对象的另外一种创建方式，<span style="color:green">这种方式可以在不修改源码的情况下，增强方法</span>。

创建对象的方式：

Dog d = new Dog();                    // 1. new
Animal a = new Dog();                 // 2. 多态
Dog.class.getConstructor().newInstance();  // 3. 反射

5.2 代理

代理：<span style="color:green">在原有功能基础上进行增强</span>。例如：房产中介可以在房东原有售卖房产、房屋出租的功能基础上，额外提供代驾、喂养宠物等服务。

// 1. 共同的接口
public interface Sale {
    void sale(double money);
    void hire(double money);
}

// 2. 被代理对象（房东）
public class Owner implements Sale {
    @Override
    public void sale(double money) {
        System.out.println("售卖房产" + money + "元");
    }

    @Override
    public void hire(double money) {
        System.out.println("出租房产" + money + "元");
    }
}

// 3. 代理对象（中介）
public class SaleImpl implements Sale {
    private Owner owner;

    public SaleImpl(Owner owner) {
        this.owner = owner;
    }

    @Override
    public void sale(double money) {
        money += 20000;       // 代理对象对功能增强（中介费）
        owner.sale(money);    // 被代理对象处理执行原有功能
    }

    @Override
    public void hire(double money) {
        money += 1000;        // 代理对象对功能增强
        owner.hire(money);    // 被代理对象处理执行原有功能
    }
}

5.3 JDK 动态代理

动态代理<span style="color:green">在运行时动态生成代理类</span>，<span style="color:red">无需手动为每个目标类编写代理类</span>。

Java 提供了 java.lang.reflect.Proxy 类，<span style="color:green">提供了使用动态代理方式创建对象的 API</span>。

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

参数介绍：

完整示例：

public class ProxyUtil {
    public static <T> T createProxy(T obj) {
        // 获取被代理对象的 ClassLoader
        ClassLoader loader = obj.getClass().getClassLoader();
        // 获取被代理对象实现的所有接口
        Class<?>[] interfaces = obj.getClass().getInterfaces();
        // 创建 InvocationHandler
        InvocationHandler h = (proxy, method, args) -> {
            // 增强逻辑
            if (method.getName().equals("sale")) {
                System.out.println("收取中介费 20000 元");
            }
            // 调用被代理对象的原方法
            return method.invoke(obj, args);
        };
        // 返回代理对象
        return (T) Proxy.newProxyInstance(loader, interfaces, h);
    }
}

public static void main(String[] args) {
    Owner owner = new Owner();
    Sale sale = ProxyUtil.createProxy(owner);
    sale.sale(1000000);   // 输出：收取中介费 20000 元 / 售卖房产1020000.0元
    sale.hire(3000);      // 输出：出租房产3000.0元
}

<span style="color:orange">小结</span>：

• <span style="color:green">动态代理</span>是对象的另外一种创建方式，这种方式可以在不修改源码的情况下，增强方法
• <span style="color:green">代理对象</span>可以在原有功能的基础上进行增强
• <span style="color:green">动态代理</span>在运行时动态生成代理类，无需手动为每个目标类编写代理类
• 使用 Proxy 中的 <span style="color:green">newProxyInstance()</span> 方法创建代理对象

课时一 振动学方程

1. 认识简谐运动

弹簧振子在水平方向上做往复运动，速度在两端最大位移处为零（$v=0$），在平衡位置处最大。可用旋转矢量法直观表示。

<img src="/images/posts/physics-oscillation/assets/1-1-弹簧振子运动.svg" alt="弹簧振子多帧运动示意" style="width:30vw;display:block;margin:0 auto;"/>

简谐运动的基本公式：

[!tip] 旋转矢量法 用一个长度为 $A$ 的旋转矢量以角速度 $\omega$ 逆时针旋转，矢量在 $x$ 轴上的投影即对应位移 $x$。矢量与 $x$ 轴的夹角即为相位 $\omega t + \varphi_0$，$t=0$ 时的夹角为初相 $\varphi_0$。

<img src="/images/posts/physics-oscillation/assets/1-1-旋转矢量法.svg" alt="旋转矢量法示意" style="width:30vw;"/>

[!tip] 弹簧串并联 弹簧串联：$\dfrac{1}{k} = \dfrac{1}{k_1} + \dfrac{1}{k_2}$ 弹簧并联：$k = k_1 + k_2$

<img src="/images/posts/physics-oscillation/assets/1-3-弹簧串并联.svg" alt="弹簧串并联模型" style="width:30vw;"/>

题1. 一质点按如下规律沿 $x$ 轴作简谐运动：$x = 0.1\cos\left(8\pi t + \dfrac{2\pi}{3}\right)$ (SI)，求此振动的周期、振幅、初相、速度最大值和加速度最大值。

解：

• 振幅 $A = 0.1,\text{m}$
• 角频率 $\omega = 8\pi$，$T = \dfrac{2\pi}{\omega} = \dfrac{2\pi}{8\pi} = 0.25,\text{s}$
• 初相 $\varphi_0 = \dfrac{2\pi}{3}$
• 速度最大值 $v_{\max} = A\omega = 0.1 \times 8\pi = 2.5,\text{m/s}$
• 加速度最大值 $a_{\max} = A\omega^2 = 0.1 \times (8\pi)^2 = 63.1,\text{m/s}^2$

题2. 质点做简谐运动，振动方程 $x = A\cos(\omega t + \varphi)$，当 $t = T/2$（$T$ 为周期）时，质点的速度为（ ）

$A.\ -A\omega\sin\varphi \quad B.\ A\omega\sin\varphi \quad C.\ -A\omega\cos\varphi \quad D.\ A\omega\cos\varphi \quad E.\ 0$

答：B

解：

$$v = \frac{dx}{dt} = -A\omega\sin(\omega t + \varphi)\Big|_{t=T/2}$$

$$= -A\omega\sin\left(\omega\cdot\frac{T}{2} + \varphi\right) = -A\omega\sin\left(\omega\cdot\frac{2\pi/\omega}{2} + \varphi\right)$$

$$= -A\omega\sin(\pi + \varphi) = A\omega\sin\varphi$$

题3. 将倔强系数为 $k$ 的轻质弹簧截去一半，然后一端固定，另一端下挂质量为 $m$ 的小球，组成振动系统。那么该系统的频率是（ ）

$A.\ \dfrac{1}{4\pi}\sqrt{\dfrac{k}{m}} \quad B.\ \dfrac{1}{2\pi}\sqrt{\dfrac{k}{m}} \quad C.\ \dfrac{1}{2\sqrt{2}\pi}\sqrt{\dfrac{k}{m}} \quad D.\ \dfrac{\sqrt{2}}{2\pi}\sqrt{\dfrac{k}{m}}$

答：D

解： 两段半弹簧并联：$\dfrac{1}{k'} + \dfrac{1}{k'} = \dfrac{1}{k} \Rightarrow k' = 2k$

$$\omega = \sqrt{\frac{k'}{m}} = \sqrt{\frac{2k}{m}}, \quad \nu = \frac{\omega}{2\pi} = \frac{\sqrt{2}}{2\pi}\sqrt{\frac{k}{m}}$$

2. 振动学方程 $x = A\cos(\omega t + \varphi_0)$

题1. 已知一物体作简谐运动，周期为 $1,\text{s}$，振动曲线如图所示，求简谐运动的余弦表达式。

<img src="/images/posts/physics-oscillation/assets/1-2-x-t曲线.svg" alt="振动曲线 x-t，A=4cm，周期 1s" style="width:30vw;display:block;margin:0 auto;"/>

解：

• 振幅 $A = 0.04,\text{m}$
• 周期 $T = 1,\text{s}$，$\omega = \dfrac{2\pi}{T} = 2\pi,\text{rad/s}$
• 由旋转矢量法得 $\varphi_0 = -\dfrac{\pi}{3}$

$$x = 0.04\cos\left(2\pi t - \frac{\pi}{3}\right)$$

题2. 一质点作简谐运动，振幅为 $A$，在起始位置时刻质点的位移为 $\dfrac{A}{2}$，且向 $x$ 轴的正方向运动，代表此简谐运动的旋转矢量图为：

答：B（位移 $x = \dfrac{A}{2}$，且向 $+x$ 方向运动 ⟹ 矢量在第一象限，逆时针旋转）

题3. 质点沿 $x$ 轴作简谐运动，用余弦函数表示，振幅为 $A$，当 $t=0$ 时，质点处于 $x_0 = -\dfrac{A}{2}$ 处且向 $x$ 轴负方向运动，则其初相为：

$A.\ \dfrac{\pi}{6} \quad B.\ \dfrac{2\pi}{3} \quad C.\ \dfrac{4\pi}{3} \quad D.\ \dfrac{\pi}{3}$

答：B

解： 由旋转矢量法，$\varphi_0 = \dfrac{2\pi}{3}$（位于第二象限，对应 $x = -\dfrac{A}{2}$ 且向 $-x$ 方向旋转分量最大处）。

<img src="/images/posts/physics-oscillation/assets/1-3-旋转矢量.svg" alt="旋转矢量 phi0=2pi/3" style="width:30vw;display:block;margin:0 auto;"/>

题4. 质点振动的 $x-t$ 曲线如图所示，求：

（1）质点的振动方程；

（2）质点从 $t=0$ 的位置到达 $P$ 点相应位置所需的最短时间。

<img src="/images/posts/physics-oscillation/assets/1-4-x-t曲线-P点.svg" alt="x-t 曲线，P 点 0.10" style="width:30vw;display:block;margin:0 auto;"/>

解：

（1）$A = 0.1$

由旋转矢量法知 $\varphi_0 = -\dfrac{\pi}{3}$，$x = 0.1\cos\left(\omega t - \dfrac{\pi}{3}\right)$

$0 = 0.1\cos\left(\omega t - \dfrac{\pi}{3}\right)$ 时 $\omega t - \dfrac{\pi}{3} = \dfrac{\pi}{2} \Rightarrow \omega = \dfrac{5\pi}{6}$

$$x = 0.1\cos\left(\frac{5\pi}{6}t - \frac{\pi}{3}\right)$$

（2）$t = 0$ 时 $\varphi_0 = -\dfrac{\pi}{3}$；$t = t_P$ 时 $\varphi_P = 0$

$$\Delta t = \frac{\Delta\varphi}{\omega} = \frac{\pi/3}{5\pi/6} = 0.4,\text{s}$$

<img src="/images/posts/physics-oscillation/assets/1-4-旋转矢量-初相-π3.svg" alt="旋转矢量 phi0=-pi/3" style="width:30vw;display:block;margin:0 auto;"/>

题5. 如图所示，质量为 $1.0\times10^{-2},\text{kg}$ 的子弹，以 $500,\text{m/s}$ 的速度射入并嵌在木块中，同时使弹簧压缩而作简谐运动。设木块质量为 $4.99,\text{kg}$，弹簧的劲度系数为 $k = 8.00\times10^3,\text{N/m}$。若以弹簧原长时木块所在处为坐标原点，向右为轴正方向，求简谐运动方程。

<img src="/images/posts/physics-oscillation/assets/1-5-子弹木块模型.svg" alt="子弹射入木块模型" style="width:30vw;display:block;margin:0 auto;"/>

解： 由动量守恒

$$mv = (M + m)v_0 \Rightarrow v_0 = \frac{m}{M + m}v = \frac{0.01}{0.01 + 4.99}\times 500 = 1,\text{m/s}$$

$$\omega = \sqrt{\frac{k}{M + m}} = \sqrt{\frac{8\times10^3}{0.01 + 4.99}} = 40,\text{rad/s}$$

$$A = \sqrt{x_0^2 + \frac{v_0^2}{\omega^2}} = \sqrt{0^2 + \frac{1^2}{40^2}} = 2.5\times10^{-2},\text{m}$$

由旋转矢量法知 $\varphi_0 = \dfrac{\pi}{2}$

$$x = 2.5\times10^{-2}\cos\left(40t + \frac{\pi}{2}\right)$$

<img src="/images/posts/physics-oscillation/assets/1-5-旋转矢量.svg" alt="旋转矢量 phi0=pi/2" style="width:30vw;display:block;margin:0 auto;"/>

课时二 振动的能量及合成

1. 振动的能量

简谐运动的机械能守恒：

• 机械能 = 动能 + 势能
• $E = \dfrac{1}{2}mv^2 + \dfrac{1}{2}kx^2$
• 在最大位移处（$x=\pm A$，$v=0$）：动能 $E_k = 0$，势能 $E_p = \dfrac{1}{2}kA^2$
• 总机械能：$E = \dfrac{1}{2}kA^2$（不变）

<img src="/images/posts/physics-oscillation/assets/2-1-振动的能量.svg" alt="振动的能量" style="width:30vw;display:block;margin:0 auto;"/>

题1. 质点做简谐运动，从平衡位置运动到最大位移处时，质点的动能 ______，势能 ______，总的机械能 ______。（填增大、减小或不变）

答： 减小，增大，不变

解： 从平衡位置（$x=0$，$v$ 最大）到最大位移处（$x=\pm A$，$v=0$），动能 $E_k = \frac{1}{2}mv^2$ 减小，势能 $E_p = \frac{1}{2}kx^2$ 增大；总机械能 $E = \frac{1}{2}kA^2$ 守恒不变。

题2. 一弹簧振子作简谐运动，当其偏离平衡位置的位移的大小为振幅的 $\dfrac{1}{4}$ 时，其动能为振动总能量的（　）。

$A.\ \dfrac{9}{16}\quad B.\ \dfrac{11}{16}\quad C.\ \dfrac{13}{16}\quad D.\ \dfrac{15}{16}$

答：D

解：

• 势能 $E_p = \dfrac{1}{2}k\left(\dfrac{A}{4}\right)^2 = \dfrac{1}{32}kA^2$
• 总机械能 $E = \dfrac{1}{2}kA^2$
• 动能 $E_k = E - E_p = \dfrac{1}{2}kA^2 - \dfrac{1}{32}kA^2 = \dfrac{15}{32}kA^2$
• $\dfrac{E_k}{E} = \dfrac{\dfrac{15}{32}kA^2}{\dfrac{1}{2}kA^2} = \dfrac{15}{16}$

题3. 有一水平的弹簧振子，弹簧的劲度系数 $k = 25,\text{N/m}$，物体质量 $m = 1.0,\text{kg}$，物体静止在平衡位置。设以水平向左的恒力 $F = 10,\text{N}$ 作用在物体上（不计一切摩擦），使其由平衡位置向左运动了 $0.05,\text{m}$，此时撤除力 $F$，当物体运动到最左边时开始计时，求物体的运动方程。

解：

• 由机械能守恒 $F\cdot x = \dfrac{1}{2}kA^2$，即 $10\times0.05 = \dfrac{1}{2}\times25\times A^2 \Rightarrow A = 0.2,\text{m}$
• 角频率 $\omega = \sqrt{\dfrac{k}{m}} = \sqrt{\dfrac{25}{1}} = 5,\text{rad/s}$
• 由旋转矢量法知 $\varphi_0 = \pi$（物体从最左边 $x=-A$ 处开始计时）
• 运动方程：$x = 0.2\cos(5t + \pi)$

2. 振动的合成

同方向同频率的两个简谐运动 $x_1 = A_1\cos(\omega t + \varphi_1)$、$x_2 = A_2\cos(\omega t + \varphi_2)$ 合成：

$$A = \sqrt{A_1^2 + A_2^2 + 2A_1A_2\cos(\varphi_2 - \varphi_1)}$$

$$\tan\varphi = \frac{A_1\sin\varphi_1 + A_2\sin\varphi_2}{A_1\cos\varphi_1 + A_2\cos\varphi_2}$$

<img src="/images/posts/physics-oscillation/assets/2-2-振动的合成.svg" alt="振动的合成" style="width:30vw;display:block;margin:0 auto;"/>

题1. 某质点同时参与轴上的两个简谐运动：$x_1 = 0.03\cos\left(2\pi t + \dfrac{\pi}{3}\right)$，$x_2 = 0.05\cos\left(2\pi t - \dfrac{2\pi}{3}\right)$（SI），合成振动的振动方程为 ______。

解：

解法一（旋转矢量法）： 相位差 $\varphi_2 - \varphi_1 = -\dfrac{2\pi}{3} - \dfrac{\pi}{3} = -\pi$，两振动方向相反，故

$$A = 0.05 - 0.03 = 0.02,\text{m},\qquad \varphi_0 = -\frac{2\pi}{3}$$

$$\Rightarrow x = 0.02\cos\left(2\pi t - \frac{2\pi}{3}\right)$$

解法二（公式法）：

$$A = \sqrt{A_1^2 + A_2^2 + 2A_1A_2\cos(\varphi_2-\varphi_1)} = \sqrt{0.03^2 + 0.05^2 + 2\times0.03\times0.05\cos(-\pi)} = 0.02$$

$$\tan\varphi = \frac{0.03\sin\frac{\pi}{3} + 0.05\sin\left(-\frac{2\pi}{3}\right)}{0.03\cos\frac{\pi}{3} + 0.05\cos\left(-\frac{2\pi}{3}\right)} = \sqrt{3}$$

由旋转矢量法可知 $\varphi = -\dfrac{2\pi}{3}$，故 $x = 0.02\cos\left(2\pi t - \dfrac{2\pi}{3}\right)$。

课时三 机械波

1. 认识机械波

机械波的形成： 波源振动带动相邻质点依次振动，振动形式在介质中由近及远传播。介质中各质点只在自己的平衡位置附近振动，不随波迁移，传播的是振动形式和能量。

<img src="/images/posts/physics-oscillation/assets/3-1-横波形成与传播.svg" alt="横波的形成与传播：绳上质点上下振动、波形向右传播，图中标出波长 λ、振动周期 T 与振幅 A" style="width:30vw;display:block;margin:0 auto;"/>

波速、波长、周期的关系：

$$u = \frac{\lambda}{T} = \lambda \nu$$

• 波速 $u$：波形传播的速度，由介质决定
• 波长 $\lambda$：一个完整波形沿传播方向占据的长度，等于波线上相位差为 $2\pi$ 的两点间距离
• 周期 $T$：波传播一个波长所需的时间，等于波源的振动周期（由波源决定）

两点间相位差：

$$\Delta\varphi = \frac{2\pi}{\lambda},\Delta x \quad\Longleftrightarrow\quad \frac{\lambda}{\Delta x} = \frac{2\pi}{\Delta\varphi}$$

[!tip] 记忆口诀 "见者有份"：波长对应 $2\pi$ 相位，两点距离 $\Delta x$ 占波长多少份，相位差就占 $2\pi$ 多少份。

波动方程（沿 +x 方向传播）

原点 $O$ 的振动方程：$y = A\cos(\omega t + \varphi_0)$

若波沿 $+x$ 方向传播，$x$ 处质点的振动比 $O$ 点落后 $\Delta t = \dfrac{x}{u}$，故

$$y = A\cos\left[\omega\left(t - \frac{x}{u}\right) + \varphi_0\right] = A\cos\left[2\pi\left(\nu t - \frac{x}{\lambda}\right) + \varphi_0\right] = A\cos\left[\omega t + \varphi_0 - \frac{2\pi}{\lambda}x\right]$$

若波沿 $-x$ 方向传播，$x$ 处质点的振动比 $O$ 点超前，则

$$y = A\cos\left[\omega\left(t + \frac{x}{u}\right) + \varphi_0\right] = A\cos\left[2\pi\left(\nu t + \frac{x}{\lambda}\right) + \varphi_0\right] = A\cos\left[\omega t + \varphi_0 + \frac{2\pi}{\lambda}x\right]$$

<img src="/images/posts/physics-oscillation/assets/3-2-波动方程推导.svg" alt="t=0 时刻波形图，y 轴标 A 与 -A，x 轴标波长 λ 与质点距离 x，波沿 +x 传播" style="width:30vw;display:block;margin:0 auto;"/>

[!warning] 易错点 判断传播方向时，"上坡下、下坡上"：在波形图上升段（沿波传播方向）质点向下振动，下降段质点向上振动。

例题

题1. 已知一平面简谐波的波动方程为：$y = 2.0\cos\left2\pi\left(t - \dfrac{x}{8}\right) + \dfrac{\pi}{3}\right$，则此波沿 $x$ 轴 ______ 方向传播，波速为 ______，波长为 ______，原点处初相为 ______。

答： 正；$8,\text{m/s}$；$8,\text{m}$；$\dfrac{\pi}{3}$

解： 波动方程与标准式 $y = A\cos\left[2\pi\left(\nu t - \dfrac{x}{\lambda}\right) + \varphi_0\right]$ 对照：

• 括号内为 $\left(t - \dfrac{x}{8}\right)$，$x$ 前为负号 ⟹ 沿 $+x$（正）方向传播
• 波长 $\lambda = 8,\text{m}$，频率 $\nu = 1,\text{Hz}$
• 波速 $u = \lambda\nu = 8\times1 = 8,\text{m/s}$
• 初相 $\varphi_0 = \dfrac{\pi}{3}$

<hr>

题2. 一横波沿绳子传播时，波的表达式为 $y = 0.05\cos(10\pi t - 4\pi x)$（SI），则（　）。

$A.\ 波长为\ 0.5,\text{m} \quad B.\ 波速为\ 5,\text{m/s} \quad C.\ 波速为\ 25,\text{m/s} \quad D.\ 频率为\ 2,\text{Hz}$

答：A

解： 对照标准式 $y = A\cos\left[\omega t + \varphi_0 - \dfrac{2\pi}{\lambda}x\right]$：

• 由 $-4\pi x = -\dfrac{2\pi}{\lambda}x \Rightarrow \lambda = 0.5,\text{m}$ ✓
• $\omega = 10\pi \Rightarrow T = \dfrac{2\pi}{\omega} = 0.2,\text{s}$
• $u = \dfrac{\lambda}{T} = \dfrac{0.5}{0.2} = 2.5,\text{m/s}$（B、C 均错）
• $\nu = \dfrac{1}{T} = \dfrac{1}{0.2} = 5,\text{Hz}$（D 错）

<hr>

题3. 频率为 $100,\text{Hz}$，传播速度为 $300,\text{m/s}$ 的平面简谐波，波线上距离小于波长的两点振动的相位差为 $\dfrac{\pi}{3}$，则两点相距（　）。

$A.\ 2.86,\text{m} \quad B.\ 2.19,\text{m} \quad C.\ 0.5,\text{m} \quad D.\ 0.25,\text{m}$

答：C

解：

$$\lambda = uT = u\cdot\frac{1}{\nu} = 300 \times \frac{1}{100} = 3,\text{m}$$

$$\Delta\varphi = \frac{2\pi}{\lambda}\Delta x \Rightarrow \frac{\pi}{3} = \frac{2\pi}{3}\Delta x \Rightarrow \Delta x = 0.5,\text{m}$$

2. 波动方程

[!note] 解题三步法 ① 求原点振动方程 $y = A\cos(\omega t + \varphi_0)$（旋转矢量法定 $\varphi_0$） ② 求波速 $u = \dfrac{\lambda}{T} = \lambda\nu$ ③ 代入波动方程 $y = A\cos\left[\omega\left(t \mp \dfrac{x}{u}\right) + \varphi_0\right]$

例题

题1. 已知一沿 $x$ 轴正向传播的平面简谐波，时间 $t = 0$ 时的波形如图所示，且 $T = 2,\text{s}$，求：

（1）$O$ 点的振动方程；

（2）该波的波动方程；

（3）$x = 60,\text{m}$ 处质点的振动方程和速度表达式。

<img src="/images/posts/physics-oscillation/assets/3-3-波形图-沿x正向.svg" alt="t=0 波形图，y 轴刻度 10/0/-10 cm，x 轴刻度 0~50 m，波长 λ=40 m，波沿 +x 传播" style="width:30vw;display:block;margin:0 auto;"/>

解：

（1）振幅 $A = 0.1,\text{m}$，$\omega = \dfrac{2\pi}{T} = \dfrac{2\pi}{2} = \pi\ \text{rad/s}$

由旋转矢量法得 $\varphi_0 = -\dfrac{2\pi}{3}$（$t=0$ 时原点位移为负、且向 $-y$ 方向运动），故

$$y = 0.1\cos\left(\pi t - \frac{2\pi}{3}\right)$$

（2）$\lambda = 40,\text{m}$，$u = \dfrac{\lambda}{T} = \dfrac{40}{2} = 20,\text{m/s}$，波沿 $+x$ 传播：

$$y = 0.1\cos\left[\pi\left(t - \frac{x}{20}\right) - \frac{2\pi}{3}\right]$$

（3）将 $x = 60,\text{m}$ 代入：

$$y = 0.1\cos\left[\pi\left(t - \frac{60}{20}\right) - \frac{2\pi}{3}\right] = 0.1\cos\left(\pi t - \frac{11\pi}{3}\right)$$

速度表达式：

$$v = \frac{dy}{dt} = -0.1\pi\sin\left(\pi t - \frac{11\pi}{3}\right)$$

<hr>

题2. 一平面简谐波在介质中以波速 $u = 2,\text{m/s}$ 沿 $x$ 轴负方向传播，原点 $O$ 处质点的振动曲线如图所示，求：

（1）原点 $O$ 的质点的振动方程；

（2）该波的波动方程；

（3）$x = 20,\text{m}$ 处质点的振动方程。

<img src="/images/posts/physics-oscillation/assets/3-4-波形图-沿x负向.svg" alt="原点振动曲线，y 轴刻度 4/0/-4 cm，t 轴刻度 0~10 s，周期 T=8 s，波沿 -x 传播" style="width:30vw;display:block;margin:0 auto;"/>

解：

（1）振幅 $A = 4\times10^{-2},\text{m}$，周期 $T = 8,\text{s}$，$\omega = \dfrac{2\pi}{T} = \dfrac{2\pi}{8} = \dfrac{\pi}{4}\ \text{rad/s}$

由旋转矢量法得 $\varphi_0 = -\dfrac{\pi}{2}$，故

$$y = 4\times10^{-2}\cos\left(\frac{\pi}{4}t - \frac{\pi}{2}\right)$$

（2）波沿 $-x$ 方向传播，$u = 2,\text{m/s}$：

$$y = 4\times10^{-2}\cos\left[\frac{\pi}{4}\left(t + \frac{x}{2}\right) - \frac{\pi}{2}\right]$$

（3）$x = 20,\text{m}$ 处：

$$y = 4\times10^{-2}\cos\left[\frac{\pi}{4}\left(t + \frac{20}{2}\right) - \frac{\pi}{2}\right] = 4\times10^{-2}\cos\left(\frac{\pi}{4}t + 2\pi\right) = 4\times10^{-2}\cos\left(\frac{\pi}{4}t\right)$$

<hr>

题3. 一平面简谐波沿 $Ox$ 轴的负方向传播，波长为 $\lambda$，$P$ 处质点的振动规律如图所示，已知 $P$ 点与 $O$ 点的距离为 $d$。

（1）求 $P$ 处质点的振动方程；

（2）求此波的波动表达式。

解：

（1）由振动图：振幅 $A$，$\varphi_0 = \pi$，$t = 1,\text{s}$ 时 $y = 0$，即

$$0 = A\cos(\omega + \pi) \Rightarrow \omega + \pi = \frac{3\pi}{2} \Rightarrow \omega = \frac{\pi}{2}$$

$$y_P = A\cos\left(\frac{\pi}{2}t + \pi\right)$$

（2）$T = \dfrac{2\pi}{\omega} = \dfrac{2\pi}{\pi/2} = 4,\text{s}$，$u = \dfrac{\lambda}{T} = \dfrac{\lambda}{4}$

以 $P$ 为原点（波沿 $-x$ 传播，$O$ 在 $P$ 的左侧 $d$ 处）：

$$y = A\cos\left[\frac{\pi}{2}\left(t + \frac{x}{\lambda/4}\right) + \pi\right] = A\cos\left[\frac{\pi}{2}\left(t + \frac{4x}{\lambda}\right) + \pi\right]$$

以 $O$ 为原点（$O$ 点比 $P$ 点振动超前 $\dfrac{d}{u}$）：

$$y = A\cos\left[\frac{\pi}{2}\left(t + \frac{4(x-d)}{\lambda}\right) + \pi\right]$$

[!tip] 波沿 $-x$ 传播的波动方程 以振动规律已知的点 $P$ 为原点，$x$ 取正方向为 $-x$ 方向；以 $O$ 为原点时，$O$ 点比 $P$ 点超前 $d/u$，故相位项为 $+\dfrac{2\pi d}{\lambda}$（对应 $t + \dfrac{x+d'}{u}$ 形式）。

目录

• 第零章 导学部分
• 第一章 开发环境搭建
• 第二章 IDEA 开发工具
• 第三章 Java 基础语法
• 第四章 运算符
• 第五章 方法
• 第六章 流程控制语句
• 第七章 数组
• 第八章 面向对象基础
• 第九章 面向对象高级
• 第十章 常用 API
• 第十一章 集合基础

第零章 导学部分

AI 智能应用开发（Java）导学视频 —— 融合 Java 核心技术与 AI 创新能力 多一句没有，少一句不行。用更短的时间，教会更实用的技术

课程介绍

课程定位与能力要求

课程总目标与时长

学习计划

什么是任务包？

任务包是老师为了帮助我们学好 Java 开发技能，将各阶段内容带分出的具体学习单元。每个任务包围绕学习目标展开，包含一系列具体的学习材料（视频、练习题等）以及预估学习时长，助力我们逐步达成学习目标，扎实吸收知识，实现高效学习。

任务包组成

任务包能带来什么好处？

学习平台：博学谷

线上学习灵活，每日任务量可动态调整，但要确保周计划整体完成。 平台提供日历视图，每日展示具体任务（前端学科就业班、Java 后端开发、20 天下载安装、学习阶段汇总、开发 Java 程序等），支持打卡、查看学习路线。

学习方法

flowchart LR
    S1["01 STEP 多动手实操"] --> S2["02 STEP 保持连贯性"] --> S3["03 STEP 学会总结"]

学习 Java 的三大步骤：<span style="color:red">多动手实操</span> → <span style="color:orange">保持连贯性</span> → <span style="color:green">学会总结</span>

学后测评

任务包练习示例（Java 核心与 AI 开发基础-任务包一[开发环境搭建]）：在 IntelliJ IDEA 中完成以下操作，创建一个 Java 工程并实现一个简单的打印功能。

①创建工程：打开 IntelliJ IDEA，创建一个名为 JavaSePractices 的空工程。 ②创建模块、包、类：在 JavaSePractices 工程中，创建一个名为 chapter01 的模块。在 chapter01 模块下，创建一个名为 com.buxuegu.demo01 的包。在 com.buxuegu.demo01 包中，创建一个名为 Test01 的类。 ③编写代码：在 Test01 类中，使用 main 方法打印 hello world 的控制台。 ④运行程序：运行 Test01 类，确保控制台输出以下内容：hello world

Java 的应用领域

<span style="color:red">Java 语言拥有 27 年发展历史，长盛不衰，是大型软件的服务端开发首选语言。</span>

Java+AI 工程师的核心能力

<span style="color:red">Java 核心功夫是王道</span> —— 不管有没有 AI，写好 Java 代码都是根本！就像学武功，马步得扎稳。你写的 Java 代码就是指挥棒！代码写得好，逻辑清晰，AI 助手才能更好地执行任务，整个系统才稳定可靠。

地基四要素

flowchart LR
    Base[("地基 Java 核心功夫")]
    Data["数据感"]
    Learn["学习力"]
    Connect["对接 AI"]
    Business["业务眼"]
    Base --- Data
    Base --- Learn
    Base --- Connect
    Base --- Business

对接 AI 案例

业务眼 — AI 落地的典型场景

4 步能力成长路径

flowchart LR
    Step1["01 扎扎实实学好 Java 编程基础 入门期间，代码需要自己动手编写 不能依赖 AI 工具"] --> Step2["02 数据意识 收集数据，整理数据，传递数据"]
    Step2 --> Step3["03 对接 AI 开发期间，可以调用现成的、强大的 AI 功能 让程序更智能"]
    Step3 --> Step4["04 业务观察力、持续学习力 分辨出哪些业务需要传统代码实现 哪些业务可以调用 AI 服务"]

课程总览（第一、第二阶段）

第一章 开发环境搭建

培养 AI 新时代 Java 工程师

Java 背景介绍

Java 语言的历史

Java 是由 James Gosling（詹姆斯·高斯林）于 1995 年在 Sun 公司开发的计算机高级编程语言，在 2009 年被 Oracle 公司收购。

James Gosling —— Java 之父

Java 的应用领域

Java 的三大技术平台

本节复习

JDK 工具的下载和安装

JDK 简介

开发 Java 程序必须先安装好 JDK（Java Development Kit），也就是 Java 开发工具包。

LTS 版本（Long-Term Support）：JDK 8、JDK 11、JDK 17、JDK 21。很多企业还在使用 JDK 8 / JDK 11。

下载步骤

在 Oracle 的官网可以找到 JDK 的下载链接：Java Downloads | Oracle 中国

安装验证

安装完成后，通过 CMD 命令行测试是否安装成功：

java -version
javac -version

JDK bin 目录核心工具

<span style="color:red">我们写好的 Java 程序都是高级语言，计算机底层是硬件，不能识别这些语言，必须先通过 javac 编译工具进行翻译，然后再通过 java 执行工具执行才可以驱动机器干活。</span>

JDK 的组成

flowchart TB
    subgraph JDK["JDK（Java Development Kit） Java 开发工具包"]
        direction TB
        subgraph JRE["JRE（Java Runtime Environment） Java 运行环境"]
            direction TB
            JVM["JVM（Java Virtual Machine） Java 虚拟机 真正运行 Java 程序的地方"]
            CoreLib["核心类库 Java 自己写好的程序 给程序员自己的程序调用"]
            JVM --- CoreLib
        end
        DevTools["开发工具 java、javac..."]
    end

DOS 常用命令

本节复习

第一个 Java 程序 Hello World

Java 程序的开发步骤

flowchart LR
    A["① 编写代码 HelloWorld.java 源代码文件"] --> B["② 编译代码 javac HelloWorld.java → 生成 HelloWorld.class"]
    B --> C["③ 运行代码 java HelloWorld → 输出 Hello World"]

D:\code>javac HelloWorld.java
D:\code>java HelloWorld
Hello World

HelloWorld 代码解析

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World !");
    }
}

Java 程序执行原理

机器语言与硬件

计算机底层都是硬件电路，可以通过不通电和通电，表示 0、1。 机器语言：由 0、1 组成，如 00011100 00110101。

编程语言发展历程

<span style="color:red">高级语言更简单</span>，使用接近人类自己的语言书写代码，再将其翻译成计算机能理解的机器指令。

Java 的跨平台原理

flowchart LR
    Java["Java 源代码"] --> Class[".class 字节码"]
    Class --> Win["Windows JVM 虚拟机"]
    Class --> Linux["Linux JVM 虚拟机"]
    Class --> Mac["MacOS JVM 虚拟机"]

<span style="color:red">总结</span>：在需要运行 Java 应用程序的操作系统上，安装一个与操作系统对应的 Java 虚拟机（JVM，Java Virtual Machine） 即可。

本节复习

Java 环境配置

Path 环境变量

<span style="color:red">Path 环境变量</span>用于记住程序路径，方便在命令行窗口的任意目录启动程序。

示例：QQ.exe 在 D:\App\QQ 目录下，从 D: 盘 >QQ、C: 盘 >qq、E: 盘 >qq 都能启动。

Path 环境变量位置：此电脑 → 属性 → 高级系统设置 → 高级 → 环境变量

Path 环境变量的原理：当我们在 Path 中配置某个程序路径后，启动命令行窗口启动程序时，系统会按 Path 中配置的目录顺序查找该程序。

JDK 的环境变量配置

较新版本的 JDK 安装时会自动配置 javac、java 程序的路径到 Path 环境变量中去，因此，javac、java 可以直接使用。

<span style="color:red">注意</span>：以前的老版本的 JDK 在安装时是没有自动配置 Path 环境变量的，此时需要自己配置 Path 环境变量。

Path 值示例：E:\develop\Java\jdk21\bin（本机路径，不要抄，去复制）

重新配置了环境变量后，必须检测是否配置成功：打开命令行窗口，输入 java -version 分别看版本提示。

JAVA_HOME：告诉操作系统 JDK 安装在了哪个位置（将来其他技术要通过这个环境变量找 JDK）。

本节复习

第二章 IDEA 开发工具

<span style="color:blue">工欲善其事必先利其器</span>

IDEA 介绍和安装

IDE 集成环境

IDE 集成环境：把代码编写，编译，执行，调试等多种功能综合到一起的开发工具。

主流 Java 开发工具

官方网站：IntelliJ IDEA – the Leading Java and Kotlin IDE (jetbrains.com)

本节小结

IDEA 中的第一个代码

IDEA 创建 Java 项目的代码结构

flowchart LR
    P["Project 工程"] --> M["Module 模块"]
    M --> Pa["Package 包"]
    Pa --> C["Class 类"]

模块化项目示例

flowchart TB
    subgraph Project["Project 项目"]
        M1["商品模块"]
        M2["搜索模块"]
        M3["订单模块"]
        M4["购物车模块"]
    end

模块内部代码结构

每个模块（Module）内部通常按职责划分为：

学习中的目录结构

<span style="color:red">整个基础篇创建一个 Project，今后每一天都创建一个新的 Module</span>

BasicCodes/                      ← Project
├── .idea/
├── day01/                       ← Module（第 1 天）
├── day02/                       ← Module（第 2 天）
├── day03/                       ← Module（第 3 天）
├── BasicCodes.iml
├── External Libraries
└── Scratches and Consoles

IDEA 的使用操作

常用操作

常用快捷键

第三章 Java 基础语法

<span style="color:blue">根基稳，万事可成</span>

注释

什么是注释

注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序的。

Java 注释的三种写法

/**
 * 通过class关键字定义了一个类，类名叫做 HelloWorld
 * public 起到限制作用，限制文件名和类名保持一致
 */
public class HelloWorld {
    public static void main(String[] args) {
        // 这是一个单行注释，有效范围是从 // 开始到当前行结尾
        System.out.println("HelloWorld");

        /*
            这是一个
            多行注释
         */
        System.out.println("HelloWorld");
    }
}

<span style="color:red">注意事项</span>：<span style="color:red">注释内容不会参与编译和运行</span>

本节小结

关键字

关键字介绍

关键字：被 Java 赋予了<span style="color:red">特定涵义的英文单词</span>。

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("HelloWorld");
    }
}

例如：class 表示"创建类"。

<span style="color:red">注意事项</span>：Java 中的关键字，已经被赋予了特殊的涵义，这些单词不允许使用。

Java 关键字大全

字面量

字面量介绍

字面量：就是程序中能直接书写的数据，学这个知识的重点是：<span style="color:red">搞清楚 Java 程序中数据的书写格式</span>。

字面量练习

需求：请将自己的个人信息打印在控制台（姓名，年龄，性别，身高，婚姻状况）

public class Main {
    public static void main(String[] args) {
        System.out.println("张三");
        System.out.println(23);
        System.out.println('男');
        System.out.println(180.1);
        System.out.println(false);
    }
}

张三
23
男
180.1
false

Process finished with exit code 0

本节小结

变量

变量的介绍和定义格式

变量就是内存中的一块区域，可以理解成一个盒子，用来<span style="color:red">装</span>程序要处理的<span style="color:red">数据</span>的。

flowchart LR
    A["数据类型 变量名称 = 变量值;"] --> B["自己起的名字"]
    A --> C["赋值"]
    A --> D["限制盒子中只能存储某种数据形式 例如：int（整数类型）、double（小数类型）"]

示例：int age = 18;

认识变量

<span style="color:red">变量有啥特点？变量里装的数据是可以被替换的。</span>

int age = 18;
age = 19;             // 把 18 替换成 19

System.out.println(age);   // 输出 19
age = age + 1;             // 在 19 的基础上 + 1，变成 20

System.out.println(age);   // 输出 20

<span style="color:red">变量有啥应用场景呢？写程序对数据进行处理就很方便了。</span>

本节小结

变量的注意事项

标识符

标识符概述

标识符：就是给类，方法，变量等起名字的符号。

public class Demo {

    public static void main(String[] args) {

        int salary = 12000;
        System.out.println(salary);

        salary = 15000;
        System.out.println(salary);

        int age = 18;
        System.out.println(age);
    }
}

标识符命名规则

<span style="color:red">硬性要求</span>（不满足则编译报错）

判断下列变量名哪些不符合规则（红色 = 不符合）：

标识符命名规范

<span style="color:green">软性建议</span>（不满足不报错，但建议遵守）

本节小结

数据类型

数据类型分类

flowchart LR
    A["数据类型"] --> B["基本数据类型"]
    A --> C["引用数据类型"]

八种基本数据类型

<span style="color:orange">说明</span>：e+38 表示是乘以 10 的 38 次方；同样，e-45 表示乘以 10 的负 45 次方。

public class Test {
    public static void main(String[] args) {
        System.out.println(10);     // 整数默认 int 类型
        System.out.println(12.3);   // 小数默认 double 类型
    }
}

编码表与 ASCII 码表

编码表：是计算机中字节到字符的一套对应关系。

ASCII 码表：American Standard Code for Information Interchange，美国信息交换标准代码。

<span style="color:red">注</span>：表中的 ASCII 字符可以用 ALT + 小键盘上的数字键 输入。

数据类型案例

需求：请将自己的个人信息，使用变量保存，并展示在控制台。

本节小结

第四章 运算符

对变量和字面量操作的符号

算术运算符

运算符分类

/ 和 % 的区别：两个数据做除法，/ 取结果的<span style="color:orange">商</span>，% 取结果的<span style="color:orange">余数</span>。

<span style="color:red">整数操作只能得到整数</span>，要想得到小数，必须有浮点数参与运算。

案例：数值拆分

需求：将数字 123 拆分出个位、十位、百位后，打印在控制台

整数123的个位为:3
整数123的十位为:2
整数123的百位为:1

公式总结：

• 个位：数值 % 10
• 十位：数值 / 10 % 10
• 百位：数值 / 10 / 10 % 10
• 千位：数值 / 10 / 10 / 10 % 10
• ……

本节小结

字符串拼接

当 + 操作中，遇到了字符串，这时 + 就是<span style="color:red">字符串连接符</span>，而不是算术运算。

public class Test {
    public static void main(String[] args) {
        System.out.println(1 + 23);                  // 24
        System.out.println("年龄为:" + 23);           // 年龄为:23
        System.out.println(1 + 99 + "年黑马");        // 100年黑马
    }
}

说明：从左到右依次运算，遇到字符串后，所有后续 + 都变为字符串拼接。

public class Test {
    public static void main(String[] args) {
        System.out.println("年龄为:" + 23 + 1);        // 年龄为:231
    }
}

计算过程：

1. "年龄为:" + 23 → "年龄为:23"
2. "年龄为:23" + 1 → "年龄为:231"

<span style="color:red">解决方案</span>：使用小括号改变运算优先级。

public class Test {
    public static void main(String[] args) {
        System.out.println("年龄为:" + (23 + 1));      // 年龄为:24
    }
}

当 + 号操作中遇到了字符串，就会变成字符串拼接。

自增自减运算符

++ 和 -- 既可以放在变量的后边，也可以放在变量的前边（参考购物车 + / - 按钮）。

本节小结

类型转换

flowchart LR
    A["类型转换"] --> B["隐式转换"]
    A --> C["强制转换"]

隐式转换介绍

把一个<span style="color:orange">取值范围小</span>的数值或者变量，<span style="color:orange">赋值</span>给另一个<span style="color:green">取值范围大</span>的变量

public class Test {
    public static void main(String[] args) {
        int a = 10;
        double b = a;          // 隐式转换：int → double
        System.out.println(b); // 10.0
    }
}

flowchart LR
    byte --> short --> int --> long --> float --> double
    char --> int

运算过程中的隐式转换

取值范围小的数据，和取值范围大的数据进行运算，小的会先提升为大的之后，再进行运算

public class Test {
    public static void main(String[] args) {
        int a = 10;
        double b = 12.3;
        double c = a + b;      // 22.3，a 临时提升为 double
    }
}

<span style="color:red">特殊规则</span>：<span style="color:blue">byte short char</span> 三种数据在运算的时候，都会先提升为 int，然后再进行运算。

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        byte c = a + b;        // 编译报错：a + b 提升为 int，需要强转
    }
}

public class Test {
    public static void main(String[] args) {
        byte a = 10;
        byte b = 20;
        int c = a + b;         // 正确：int 接收
    }
}

char 与 int 相加时，char 会提升为 int（按 ASCII 码取值）。

public class Test {
    public static void main(String[] args) {
        int a = 1;
        char b = 'a';
        int c = a + b;         // 98（'a' 对应 ASCII 码 97）
        System.out.println(c);
    }
}

强制类型转换

把一个<span style="color:orange">取值范围大</span>的数值或者变量，<span style="color:orange">赋值</span>给另一个<span style="color:red">取值范围小</span>的变量

<span style="color:red">不允许直接赋值</span>，需要加入强制转换

格式：目标数据类型 变量名 = (目标数据类型) 被强转的数据;

public class Test {
    public static void main(String[] args) {
        double a = 12.3;
        int b = (int) a;       // 12（精度损失，小数部分丢失）
        System.out.println(b);
    }
}

本节小结

赋值运算符

基本赋值运算符

扩展赋值运算符

<span style="color:red">注意</span>：扩展赋值运算符隐含了强转效果。

本节小结

<span style="color:red">警告</span>：== 是关系运算符，= 是赋值运算符，不要混淆！

关系运算符

关系运算符最终返回的都是 boolean 类型的结果。

逻辑运算符

把多个条件放在一起运算，最终返回<span style="color:blue">布尔类型</span>的值：true、false

连接布尔类型的表达式，或者是值。

案例：判断成绩是否优秀

需求：在程序中，判断一个学生成绩是否在 90~100 之间，是的话程序输出优秀。

public class Test {
    public static void main(String[] args) {
        int score = 95;
        System.out.println(score >= 90 & score <= 100);  // true
    }
}

逻辑运算符分类

短路逻辑运算符

flowchart LR
    A["& 逻辑与"] --> A1["遇 false 则 false"]
    B["&& 短路与"] --> B1["左边为 false 右边不执行"]
    C["| 逻辑或"] --> C1["遇 true 则 true"]
    D["|| 短路或"] --> D1["左边为 true 右边不执行"]
    E["! 逻辑非"] --> E1["取反"]
    F["^ 逻辑异或"] --> F1["相同是 false 不同是 true"]

<span style="color:red">注意</span>：实际开发中，常用的逻辑运算符是：&&、||、!

三元运算符

格式：判断条件 ? 值1 : 值2;

执行流程：

1. 首先计算<span style="color:red">判断条件的值</span>
2. 如果值为 <span style="color:green">true</span>，<span style="color:blue">值 1</span> 就是运算结果
3. 如果值为 <span style="color:red">false</span>，<span style="color:blue">值 2</span> 就是运算结果

flowchart LR
    A["判断条件 ?"] --> B{"判断条件的值"}
    B -- true --> C["值 1 （运算结果）"]
    B -- false --> D["值 2 （运算结果）"]

<span style="color:green">总结</span>：根据判断条件，从两份数据中二者选其一。

运算符优先级

<span style="color:orange">规律</span>：&& 优先级高于 ||，赋值运算符优先级最低。

优先级案例解析

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a > b || a < b && a > b);
        // 解析：&& 优先级高于 ||，先算 a < b && a > b（false），再算 a > b || false（false || false = false）
    }
}

<span style="color:red">小技巧</span>：不确定优先级时，用 () 改变优先级，可读性更强。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println((a > b || a < b) && a > b);
        // 显式加括号：先算 a > b || a < b（true），再算 true && a > b（true && false = false）
    }
}

Scanner 键盘录入

需求

请在程序中，提示用户通过键盘输入自己的姓名、年龄，并能在程序中收到这些数据。

Java 已经写好了实现程序，我们调用即可。

三个步骤

import java.util.Scanner;       // ① 导包：告诉程序去 JDK 的哪个包中找扫描器技术

public class Test {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);  // ② 创建对象：代表得到键盘扫描器对象

        System.out.println("请输入您的年龄：");
        int age = sc.nextInt();              // ③ 调用方法：等待接收用户输入数据
        System.out.println("年龄是：" + age);

        System.out.println("请输入您的名称：");
        String name = sc.next();
        System.out.println("欢迎：" + name);
    }
}

本节小结

Java 程序中如何实现接收用户键盘输入的数据？

使用 Java 提供的类 Scanner 来完成，<span style="color:red">步骤</span>如下：

第五章 方法

函数，实现特定功能的操作步骤集合

方法的介绍

为什么要使用方法

如果将所有功能都写在 main 方法中，代码会臃肿（"臃肿"），不便于维护。

public class Test {
    public static void main(String[] args) {
        // ...50 行代码
    }
}

解决方法：将每个功能单独封装到一个方法中，main 中只负责调用。

public class Test {
    public static void main(String[] args) {

    }

    /** 查看全部商品 */
    public static void showGoodsInfo() { ... }

    /** 上架商品 */
    public static void addGoods() { ... }

    /** 下架商品 */
    public static void deleteGoods() { ... }

    /** 修改商品 */
    public static void updateGoods() { ... }
}

方法的概念

小结

方法（函数）就是将<u>具有独立功能的代码</u>封装起来，组成一个独立的小工具，方便重复使用，提升维护性。

方法的基本定义和调用

定义和调用格式

public class Test {
    public static void show() {
        // 方法体
    }

    public static void main(String[] args) {
        show();   // 调用
    }
}

案例：方法计算两个整数最大值

需求：定义一个方法，方法中定义两个整数变量，求出最大值并打印在控制台

方法的执行流程

方法的调用流程

flowchart LR
    A["方法区 字节码文件 例如 main"] -->|被调用| B["栈内存 方法运行时进入的内存"]

入栈与出栈

public class MethodDemo1 {
    public static void main(String[] args) {
        System.out.println("开始");
        getMax();
        System.out.println("结束");
    }

    public static void getMax() {
        int num1 = 10;
        int num2 = 20;
        int max = num1 > num2 ? num1 : num2;
        System.out.println(max);
    }
}

执行流程：

flowchart TD
    M["main 压栈 执行 println 开始"] --> G["getMax 压栈 求 max = 20"]
    G --> G1["println 打印 20"]
    G1 --> G2["getMax 执行完毕 出栈"]
    G2 --> M1["main 继续执行 println 结束"]
    M1 --> M2["main 执行完毕 出栈"]

多个方法嵌套调用

public class MethodDemo2 {
    public static void main(String[] args) {
        study();
    }

    public static void sleep() {
        System.out.println("睡觉");
    }

    public static void eat() {
        System.out.println("吃饭");
    }

    public static void study() {
        eat();
        System.out.println("学习");
        sleep();
    }
}

小结

带参数的方法

为什么要带参数

方法中写死的数据不灵活，每次只能处理固定的内容。

public class MethodDemo1 {
    public static void main(String[] args) {
        getMax();
    }

    public static void getMax() {
        int num1 = 10;
        int num2 = 20;
        int max = num1 > num2 ? num1 : num2;
        System.out.println(max);
    }
}

上面的 getMax() 只能计算 10 和 20 的最大值。<br> 解决办法：让方法可以接收调用方传入的数据 → 形参 + 实参

定义格式

public static void call(String name) {
    // ...
}

public static void add(int a, int b) {
    // ...
}

调用格式

call("钢门吹雪");
add(10, 20);

形参和实参

public class MethodDemo2 {
    public static void main(String[] args) {
        getMax(10, 20);   // 10、20 是实参
    }

    public static void getMax(int num1, int num2) {  // num1、num2 是形参
        int max = num1 > num2 ? num1 : num2;
        System.out.println(max);
    }
}

小结

带返回值的方法

为什么需要返回值

A 方法产生的数据，B 方法想要使用的话，就需要定义带返回值的方法

// 之前：A 方法中计算 sum，B 方法想用 sum 是用不了的
public static void methodA(int a, int b) {
    int sum = a + b;
    // ...
}

public static void methodB() {
    System.out.println(sum % 2 == 0);   // 报错，拿不到 sum
}

// 现在：A 方法通过 return 把数据交给 B 方法
public static int methodA(int a, int b) {
    int sum = a + b;
    return sum;
}

public static void methodB() {
    int result = methodA(10, 20);
    System.out.println(result % 2 == 0);
}

定义格式

public static 数据类型 方法名 (数据类型 变量名1, 数据类型 变量名2...) {
    return 数据值;
}

public static int add(int a, int b) {
    int c = a + b;
    return c;
}

public static double getNum() {
    return 12.3;
}

调用格式

add(10, 20);                    // 单纯调用，返回值被丢弃
int result = add(10, 20);       // 用变量接收

小结

方法通用定义格式

完整格式

public static 返回值类型 方法名(参数) {
    方法体;
    return 数据;
}

定义方法的两个明确

调用方法的两种方式

案例

方法注意事项

// 错误示例：return 之后还有代码
public class MethodDemo {
    public static void method() {
        // 代码片段
        return;
        System.out.println("卑微代码");   // ❌ 报错
    }
}

方法重载

引入

需求：提供 4 个计算方法，功能如下

• 2 个 int 相加
• 2 个 double 相加
• 3 个 int 相加
• 3 个 double 相加

public class Test {
    public static int add1(int a, int b) {
        return a + b;
    }

    public static double add2(double a, double b) {
        return a + b;
    }

    public static int add3(int a, int b, int c) {
        return a + b + c;
    }

    public static double add4(double a, double b, double c) {
        return a + b + c;
    }
}

但是 4 个 add1/add2/add3/add4 名字太繁琐了，<br> 能否全部用 add 同一个名字？→ 方法重载

public class Test {
    public static int    add(int a, int b)              { return a + b; }
    public static double add(double a, double b)        { return a + b; }
    public static int    add(int a, int b, int c)       { return a + b + c; }
    public static double add(double a, double b, double c) { return a + b + c; }
}

flowchart LR
    C1["add(10, 20)"] --> M1["add(int, int)"]
    C2["add(10, 20, 30)"] --> M2["add(int, int, int)"]
    C3["add(12.3, 12.3)"] --> M3["add(double, double)"]
    C4["add(12.3, 12.3, 12.3)"] --> M4["add(double, double, double)"]

调用方法的时候，Java 虚拟机会<span style="color:red">通过参数的不同来区分同名的方法</span>

方法重载的定义

简单记：同一个类中，方法名相同，参数不同的方法<br> 参数不同：<span style="color:green">个数不同、类型不同、顺序不同</span>

<span style="color:red">注意：识别方法之间是否是重载关系，只看方法名和参数，跟返回值无关。</span>

重载判断正误