hecloud.top

00 概述

Fri, 28 Aug 2026 00:00:00 GMT

本分类是Java SE的学习笔记，是我个人的根据《Java核心技术卷》的一些知识总结，如有纰漏，欢迎指出。本分类会被作为知识节点串连进入后端路线或者其它用到Java SE的技术路线中。本教程的运行环境是MacOS，不过鼓励读者在任意平台探索，体会Unix家族和Windows的差异。本系列创作过程使用AI辅助创作尽可能避免错误。

上一学年遗憾博客停更，C语言程序设计入门和数据结构部分没有被整理发布，未来如果有时间一定会把C语言部分按照严长生的《C语言小白变怪兽》教程补上，当然我也并非闲的蛋疼，C语言是学习Java SE的前置知识，本笔记也仅面向已掌握C语言的群体。

算法竞赛实际上是高级数据结构+算法，可以说包含了通俗的数据结构课程知识，我会按照罗勇军的《算法竞赛》分类将数据结构部分作为知识节点发布，内容扩充了传统的数据结构课程知识。

我的博客体系就是如此，因为需要用到Java SE的方向一定不仅有后端开发，所以每一个具体知识点我都节点化，在多个路线中共享。

卷一#

章	内容	去向	系数
Ch1	Java 概述	✅ ①	1
Ch2	编程环境	✅ ①	1
Ch3	基本结构（类型/字符串/数组/控制台IO/大数值/日期）	✅ ①	2
Ch4	对象与类（封装/构造/包/文档注释/Object方法）	✅ ②	3
Ch5	继承（多态/抽象/枚举/反射）	✅ ③	3
Ch6	接口/lambda/内部类（服务加载/clone/序列化）	✅ ④	3
Ch7	异常/断言/日志	✅ ⑤	2
Ch8	泛型（通配符/擦除）	✅ ⑥	2
Ch9	集合（含遗留集合/Properties）	✅ ⑦	2
Ch10	GUI 程序设计	❌ 跳	—
Ch11	Swing 组件	❌ 跳	—
Ch12	并发（线程/锁/原子/线程池/CompletableFuture/进程）	✅ ⑧	4

卷二#

章	内容	去向	系数
Ch1	流（Stream API：filter/map/collect/Optional/并行流）	✅ ⑨	2
Ch2	输入输出（IO 流/文件/序列化/正则/NIO）	✅ ⑩	3
Ch3	XML（DOM/SAX/StAX/XPath）	🔀 按需（JSON 为主）	1
Ch4	网络编程（Socket/HttpClient/HTTP Server）	✅ ⑪	2
Ch5	数据库编程（JDBC/事务/连接管理）	✅ ⑬	3
Ch6	日期时间（java.time 进阶，卷I Ch3 已有基础）	✅ 并入①，进阶按需	1
Ch7	国际化	❌ 跳	—
Ch8	编译与脚本（编译 API / 脚本引擎）	❌ 跳	—
Ch9	安全（类加载器/认证/签名/加密）	🔀 按需（平台安全 API，≠后端 Web 安全）	1
Ch10	GUI 程序设计	❌ 跳	—
Ch11	Swing 组件	❌ 跳	—
Ch12	高级 Swing 与图形	❌ 跳	—
Ch13	外部函数与本地方法（FFM/JNI）	❌ 跳	—

第 1 章 Java 程序设计概述

Fri, 28 Aug 2026 00:00:00 GMT

1.1 Java 程序设计平台#

Java是一个完整的平台，有庞大的库，有大量可以直接抄的代码，有可以保证安全性、跨操作系统、内存垃圾回收的环境，集多种优势于一身。

1.2 Java 白皮书的关键术语#

简单性：几乎所有编程语言的推出的目的都是优化上一代编程语言的不足，Java就是在C++的特性上剔除了许多难以理解的功能。而且刚刚推出时完整占用仅在Kb级别面向对象：（一种程序设计技术）将重点放在数据上而非工具上。分布式：网络功能强大，可以打开和访问云端对象。健壮性：其指针模型可以消除重写内存和损坏数据的可能，编译器可以在运行前检测出问题。安全性：具备沙箱功能，不可信代码隔离运行。体系结构中立：编译后生成的字节码可以在任何有JRE的环境运行，和计算机体系无关。可移植性：基本数据类型和运算行为是明确的，比如int类型的大小在任何机器上都是固定的。解释性：不是纯编译型语言，先编译出字节码之后解释器翻译成机器码高性能：靠JIT即时编译，把运行次数最多的代码片段直接编译成机器码。现代的优化直逼C/C++ 多线程：第一个在语言层面内置多线程，无需附加库。动态性：按需动态加载新代码。

以上特性需要在后续学习中体会，纯看理解不了

1.3 Java applet 与 Internet#

运行在网页上的java代码是applet，开发者在网页上设计java程序发布字节码，用户端直接用本地解释器运行，当时很牛，但马上被flash碾压。

1.4 Java 发展简史#

Java 诞生于 1991 年 Sun 公司的 “Green 项目”。James Gosling 等人最初的设想是给嵌入式消费电子产品（电视机顶盒、遥控器之类）写一门语言，当时取名 Oak（橡树）。可惜产品没有找到市场，项目一度濒临放弃。

转机出现在 1995 年。互联网爆发式增长，Sun 发现网络上的设备五花八门、平台极不统一，而 Oak 的跨平台特性（编译成字节码、由各平台 JVM 解释执行）正好命中了 Web 时代的需求。于是 Oak 改名 Java 正式发布，并借助浏览器运行小程序（applet）一战成名。“一次编写，到处运行”（Write Once, Run Anywhere）成为 Java 最深入人心的口号。

此后 Java 一路快速迭代，几个关键节点：

1996 JDK 1.0 正式版
1997 JDK 1.1：内部类、反射、JDBC、RMI
1998 Java 2（1.2）：Swing、集合框架、JIT 编译器
2004 Java 5：泛型、注解、枚举、自动装箱、并发包 —— 现代 Java 的基石
2006 Java 6：脚本引擎、JDBC 4.0
2009 Oracle 收购 Sun 公司
2011 Java 7：try-with-resources、switch 支持字符串、NIO.2
2014 Java 8：lambda、Stream、java.time、接口默认方法 —— 另一个里程碑
2017 Java 9：模块系统、JShell；此后改为每半年发一版
2018/2021/2023 Java 11 / 17 / 21：长期支持版本（LTS）

只要抓住两个关键版本就够了：Java 5 定下了泛型、注解、并发这些基础语法；Java 8 是写法的分水岭，lambda 与 Stream 让 Java 从”啰嗦的 C++ 改良版”进化成了现代化的语言。之后的版本大多是在这个地基上做增量。本书正是基于这一生态展开的。

1.5 关于 Java 的常见误解#

“Java 很容易学” 语法确实比 C++ 温和，但”学语法”和”会写程序”是两码事。Java 真正的难度在生态：JVM、集合、并发、框架。入门容易，精通极难——就像 C 语法也不难，指针和内存才是坎。

“Java 能取代所有语言” 没有万能语言。C/C++ 统治系统编程与游戏引擎，Python 主导 AI，JavaScript 垄断浏览器，Go/Rust 在云原生崛起。Java 的天下是企业级后端，它再强也取代不了所有场景。

“Java 不过是换了个写法的 C/C++” 这是最值得掰扯的一条。两者的差异不在语法在运行模型：C++ 编译成机器码直接跑，Java 编译成字节码交给 JVM；C++ 手动管内存，Java 自动回收；C++ 指针能算数，Java 引用不行。同样的逻辑任何语言都能表达，但各自解决不同层面的问题——这正是本系列要慢慢体会的。

“Java 是闭源的” 反了。OpenJDK 是开源实现（GPL 许可），语言演进走公开的 JSR 流程。Oracle JDK 也只是基于 OpenJDK 的发行版。把「有大厂主导」说成「闭源」是个误会。

“JavaScript 是 Java 的简易版” 俩名字都带 “Java” 而已。Java 是 Sun 的静态类型面向对象语言，跑在 JVM；JavaScript 是 Netscape 为浏览器发明的脚本语言，跑在浏览器引擎。语法、类型系统、运行环境全都不一样，纯属当年蹭热度起的名字。

“Java 性能低下” 20 年前的刻板印象。早期纯解释执行确实慢，但 JIT 会把热点代码编成机器码，现代 JVM 峰值性能逼近 C++（大厂的高并发服务很多就是 Java）。真正的代价是启动慢、吃内存——它是「用启动速度和内存换运行性能」。

“Java 写程序容易有安全风险” 恰恰相反，Java 的安全设计是核心卖点：没有指针算术杜绝内存破坏、字节码校验、数组越界检查、沙箱机制。C/C++ 里缓冲区溢出、野指针这类经典漏洞，在 Java 里从机制上就没了。Java 的安全问题更多在应用层（框架配置、依赖漏洞），那是所有语言都躲不掉的。

第 2 章 Java 编程环境#

Hello.java（源代码） │ ① javac Hello.java ▼ Hello.class（字节码 bytecode，磁盘文件） │ ② java Hello（启动 JVM） ▼ JVM：类加载 → 字节码校验 → 执行引擎 │ ③ 解释执行 + JIT 即时编译（热点代码） ▼ 机器码（二进制，内存中，CPU 真正执行）

2.1 安装 Java 开发工具包#

https://www.java.com/zh-CN/

Java 的开源本体只有 OpenJDK 一份，Azul Zulu、Amazon Corretto、Eclipse Temurin、Oracle JDK 等全部是基于这同一份源码编译出的发行版——内核相同，差异只在打包方式、支持周期和性能优化。类比 Linux 内核 vs Ubuntu/Fedora。

运行安装程序一路下一步即可完成安装，除非你非要编译安装。记得勾选添加系统环境变量、Add to PATH一类的标识。

运行以下命令，即可查看java版本。（一般装cli软件这一步是必须做的）

Terminal window

1
javac --version

如果报错未找到command not find，多半是你忘了勾选添加环境变量，win用户去设置内找编辑系统环境变量的对话框，手动把你安装java的根目录添加于此。unix-like用户（Linux、MacOS）去~/.zshrc或~/.bashrc文件加一行export PATH=jdk/bin:$PATH(jdk/bin是linux默认安装位置，如果你装在别处请改写)

2.2 使用命令行工具#

学习Java需要具备一定的命令行基础，Java SE相关笔记中会体现一些基本用法。命令行主流教学基本都是 Unix‑like，相关深入用法在 Linux 基础与命令行 节点深入详解。

新建hw.java文件，输入

1
public class Hello {
2
    public static void main() {
3
        System.out.println("Hello World!");
4
    }
5
}

在同级目录下，使用命令

Terminal window

1
javac Hello.java
2
#先用编译器生成class字节码
3
java Hello
4
#再用JVM翻译成机器码，输出第一个hello world

以上过程初学者可能会发现一些必须要遵守的写java程序必须要遵守的原则，简称语法。遵守这些规则怪谈才能不出bug。

2.3 使用集成开发环境#

集成开发环境（IDE，Integrated Development Environment）把编辑、编译、运行、调试、代码补全等工具整合到一个图形界面里，省去手动敲命令的麻烦。

本系列使用 IntelliJ IDEA（JetBrains 出品），业界主流的 Java IDE。它分两个版本：

Community（社区版）：免费开源，本阶段够用
Ultimate（旗舰版）：付费，内置 Spring、数据库等企业开发支持——后面走后端路线时用得上

用 IDEA 跑 Hello World，本质就是把 2.2 的命令行两步（javac 编译、java 运行）搬进图形界面：新建项目 → 指定 JDK → 写代码 → 点运行。

2.4 JShell#

JShell 是 Java 9 起自带的交互式命令行工具（REPL，Read-Eval-Print Loop），类似 Python 的交互式 shell：敲一行、立刻看到结果，不用建文件、编译、运行。

终端敲 jshell 进入，试几条：

1
jshell> System.out.println("Hello World!")
2
Hello World!
3

4
jshell> 1 + 1
5
$1 ==> 2
6

7
jshell> "abc".repeat(3)
8
$2 ==> "abcabcabc"

与 Python shell 的手感差异源于语言本身：Java 声明变量要写类型（int x = 5;），语句结尾要分号。而且 JShell 只是「试用台」——验证语法、算表达式、试 API 很方便，而且还能使用tab键补全查函数名，但正经程序还是走 2.2 的编译运行或 2.3 的 IDEA。对比 C：C 没有官方 REPL，想试个语法得写文件编译，Java 这一点更顺手。

第 3 章 Java 的基本程序设计结构#

3.1 一个简单的 Java 程序#

从 Hello World 起手，对照 C 最容易看清 Java 的程序骨架，很多新概念、新名词在这里先露个脸、留个印象，具体的深入剖析需要到之后的章节。

1
public class Hello {
2
    public static void main(String[] args) {
3
        System.out.println("Hello World!");
4
    }
5
}

类名与文件名：public class Hello 声明一个公共类，类名 Hello。类名习惯以大写字母开头；源文件名必须与公共类同名（Hello.java）。Java 里所有内容都必须放进类的容器中——C 可以在文件顶层写自由函数，Java 不行，这就是「万物皆类」的起点。

访问修饰符：public 表示「公开」，谁都能访问。Java 的类、方法、字段前面几乎都有修饰符（public / private 等）控制可见性，C 没有对应概念，只能靠文件作用域和头文件的约定来模拟。

main 方法——程序入口：public static void main(String[] args)，逐词拆解：

public：JVM 要从外部调用它，必须公开
static：静态方法，不需要创建对象就能调用
void：不返回值
String[] args：命令行参数数组，对应 C 的 int argc, char *argv[]（Java 只保留了参数那半，argc 用 args.length 代替）

执行 java Hello 时，JVM 从 Hello 类的 main 方法开始运行。Java 里函数叫方法（method），等价于 C++ 的成员函数。

调用方法：通用语法是 对象.方法(参数)。System.out.println("Hello World!") 中，System 是一个类，out 是它内部代表标准输出的对象，println 是对象的方法——对应 C 的 printf。区别在于 C 调用的是库函数，Java 调用的是对象的方法，这是面向对象和面向过程的第一处体感差异。

大小写敏感：Java 严格区分大小写，Hello 和 hello 是两回事，main 必须小写。C 同样区分大小写，但 Java 的驼峰命名惯例（类名大写开头、方法变量小写开头）从一开始就要适应。

3.2 注释#

几乎所有编程语言的注释都不会出现在可执行程序中——它们只是写给编译器和人看的说明，编译时被直接丢弃。

三种注释方式，一段代码全演示：

1
public class CommentDemo {
2
    /**
3
     * 文档注释：/** */ 之间的内容，
4
     * 可用 javadoc 工具生成 HTML 文档
5
     */
6
    public static void main(String[] args) {
7
        // 单行注释：// 到行尾都被忽略
8
        System.out.println("Hello");  // 也可以跟在代码后面
9

10
        /*
11
         * 多行注释：/* */ 之间的内容
12
         * 跨越多行全部忽略
13
         */
14
        System.out.println("World!");
15
    }
16
}

展开收起

不能嵌套：三种注释都不能互相嵌套，尤其多行注释——/* 外层 /* 内层 */ 外层 */ 是错的：编译器遇到第一个 */ 就认为注释结束，后面剩的 外层 */ 会被当成代码，直接编译报错。

对比 C：// 和 /* */ 与 C 一致；/** */ 是 Java 新增的文档注释（C 没有），配合 javadoc 工具生成 API 文档。

小提示：示例中多行注释和文档注释每行开头的 * 并非语法要求，只是排版风格——Java 只认开头的 /* 或 /** 和结尾的 */，中间怎么写都行，IDEA 会自动帮你补 *。

3.3 数据类型#

Java 有 8 种基本数据类型，每种的大小在所有平台上都固定不变——这是和 C 最根本的差异之一：C 的 int 在 16/32/64 位机器上是 2/4/4 字节，Java 的 int 永远是 4 字节，跨平台行为完全一致。

类型	存储	取值范围	字面量后缀
`byte`	1 字节	-128 ~ 127	无
`short`	2 字节	-32,768 ~ 32,767	无
`int`	4 字节	-21.4 亿 ~ 21.4 亿	无（整数默认）
`long`	8 字节	-922 亿亿 ~ 922 亿亿	`L` / `l`
`float`	4 字节	约 ±3.4E38（6~7 位有效数字）	`F` / `f`（必须写）
`double`	8 字节	约 ±1.8E308（15 位有效数字）	`D` / `d`（可省，浮点默认）
`char`	2 字节	0 ~ 65,535（无符号）	单引号 `'A'`
`boolean`	不规定	`true` / `false`	无

（E 是科学计数法，3.4E38 = 3.4 × 10³⁸）

整型：整数默认是 int，超过范围加 L（后缀建议大写，小写 l 和数字 1 长得太像）。支持多种进制前缀：

1
int dec = 10;      // 十进制（默认）
2
int oct = 010;     // 八进制：0 开头，值 = 8
3
int hex = 0x10;    // 十六进制：0x 开头，值 = 16
4
int bin = 0b10;    // 二进制：0b 开头（Java 7+），值 = 2

长数字可以用 _ 分组（Java 7+，编译时忽略）：1_000_000 就是 100 万。_ 不能放在开头/结尾、小数点两侧、以及 L/F 后缀前，比如 _100、100_.0 都非法。

vs C：Java 没有无符号数。C 有 unsigned int，Java 所有整数类型都是带符号的，唯一的”无符号”是 char——但它是字符类型，不做算术。

浮点型：带小数默认是 double，存 float 必须写 F 后缀。遵循 IEEE 754 标准，浮点运算有 3 种特殊结果：

Double.POSITIVE_INFINITY 正无穷，如 1.0 / 0
Double.NEGATIVE_INFINITY 负无穷，如 -1.0 / 0
Double.NaN 非数字，如 0.0 / 0

判断 NaN 必须用 Double.isNaN(x)——因为 NaN 不等于任何值，包括它自己，x == Double.NaN 永远为 false。

字符型：char 是 2 字节无符号(C/C++是1字节)，直接表示 Unicode 字符。有个著名大坑：Java 在解析代码之前就先处理 Unicode 转义（\uXXXX），所以写 Windows 路径 "c:\users" 会编译报错——\u 被当成 Unicode 转义开头，而 \users 不是合法的十六进制序列。改成 "c:\\users" 或 "c:/users" 就好。

顺带解释码点（code point）：Unicode 给每个字符分配的唯一编号就是码点，范围 0 ~ 0x10FFFF（约 110 万）。char 只有 16 位，只能直接装 0~65535 的码点（基本多语言平面）；更大的码点（如 emoji）要两个 char 拼成「代理对」表示。意思就是码点可能是一个char也可能是两个char拼起来的代理对。这就是 3.6 字符串「码点与代码单元」要展开的话题。

布尔型：boolean 只有 true / false，和 C/C++ 最大的区别是不能用数字代替——if (1) 在 Java 里是编译错误，必须写布尔表达式。这也顺带杜绝了 C 里”赋值写进条件”那类经典 bug。

3.4 变量与常量#

声明变量：先声明后使用，命名规则：

以字母开头，后面可接字母、数字、_、$，大小写敏感，注意不能用关键字当变量名（class、int、if…）
Java 的”字母”包含 Unicode 字符，支持中文变量名
惯例：驼峰命名、下划线命名，如 int totalCount; int total_count;

1
double salary;       // 声明
2
int i, j;            // 一行声明多个

不区分声明和定义：C/C++ 里声明（告诉编译器类型）和定义（分配存储）是两回事，于是有 extern、头文件、前置声明。Java 没有这套——每个声明天然就是定义，变量一旦声明就真实存在、占存储，因此也不需要头文件。
初始化：Java 编译期强制要求局部变量使用前必须赋值，否则直接编译报错：

1
int x;
2
System.out.println(x);   // 编译错误：变量 x 可能尚未初始化

C/C++ 里这属于未定义行为（可能读到垃圾值），Java 把这种错误直接拦在编译期。

作用域（块作用域）：变量在声明它的块 { } 内有效，块结束即失效，这点和 C 一致。但有个关键差异——Java 禁止遮蔽（shadowing）：

1
int x = 0;
2
{
3
    int x = 1;   // C/C++ 合法（内层遮蔽外层），Java 编译错误！
4
}

C/C++ 允许内层块重新声明同名变量（内层隐藏外层），Java 直接拒绝同名局部变量同时存在于同一作用域链。另外，Java 没有全局变量：C 有文件作用域的全局变量，Java 一切都在类内，最接近的等价物是类里的 static 字段（详见后文对象与类）。

常量：用 final 声明，只能赋值一次：

1
final double CM_PER_INCH = 2.54;

对比 C：C 用 #define（预处理器文本替换，无类型检查）或 const（编译器只读）。Java 的 final 语义更强——基本类型 final 变量的值不可变。类级常量用 static final 声明。

枚举类型：Java 5+ 引入，定义一组有限的值：

1
enum Size { SMALL, MEDIUM, LARGE }

C 也有 enum，但 Java 的枚举是完整的类，能力远超 C（能带字段和方法），细节放到继承那篇展开。

3.5 运算符#

算术运算符：+ - * / % 与 C 一致：

1
int a = 10, b = 3;
2
a / b   // 3：整数除法直接截断（向 0 取整）
3
a % b   // 1：取余

一个 vs C 的差异：Java 里整数除零直接抛异常（ArithmeticException），浮点除零则是无穷或 NaN；C 的整数除零是未定义行为，程序可能悄悄崩掉。

Math 类：Java 的数学函数都收在 Math 类里，静态调用即可，不需要 #include <math.h> 也不用链接 -lm：

1
Math.sin(x)      // 正弦
2
Math.cos(x)      // 余弦
3
Math.tan(x)      // 正切
4
Math.atan(x)     // 反正切（弧度）
5
Math.atan2(y, x) // 直角坐标 → 极坐标的角度
6
Math.exp(x)      // e^x
7
Math.log(x)      // 自然对数 ln(x)
8
Math.log10(x)    // 以 10 为底的对数
9
Math.pow(a, b)   // a 的 b 次方
10
Math.PI          // 圆周率 π
11
Math.E           // 自然常数 e

注意：三角函数参数是弧度，不是角度。

隐式类型转换：小范围类型自动转大范围类型（隐式「拓宽」转换），合法转换如图：

1
byte → short → int → long → float → double
2
               ↑
3
               char

实线箭头无损、可隐式转换。另有几条虚线转换（int→float、long→float、long→double）虽合法但可能损失精度，因为 float/double 的尾数位有限。

隐式转换：

赋值：double d = 3;（右侧自动拓宽成左侧类型）

算术运算：3 + 3.14（窄操作数自动提升成宽操作数）

二元运算时数值会自动提升：操作数里有 double 结果就是 double，其次 float、long，否则一律提升到 int——所以 byte + byte 的结果也是 int。原因是 JVM 的字节码指令没有 byte/short 级别的算术运算，一律按 int（或更大）宽度计算，这和 C 的整型提升（integer promotion）如出一辙。后果就是：

1
byte a = 10, b = 20;
2
byte c = a + b;          // 编译错误：a + b 是 int，不能直接赋给 byte
3
byte d = (byte) (a + b); // 正确：强转回来

强制类型转换：大范围转小范围（「缩小」转换）必须显式强转，语法 (目标类型) 表达式：

1
double x = 9.997;
2
int n = (int) x;   // 9：直接截断小数，不是四舍五入

想要四舍五入用 Math.round(x)，不是强转
大转小可能溢出或截掉高位（如 int → byte），结果可能出乎意料
boolean 不能转数值，数值也不能转 boolean

赋值运算符：= 之外还有复合赋值 += -= *= /= %= &= |= ^= <<= >>= >>>=：

1
x += 4;   // 等价于 x = x + 4;

一个小坑：复合赋值自带一次隐式强转——byte b = 1; b += 1; 合法（等价于 b = (byte)(b + 1)），而 b = b + 1; 编译报错。

自增自减：++ -- 与 C 完全一致，注意前后缀的区别：

1
int x = 5;
2
int y = x++;   // y = 5，先用后加
3
int z = ++x;   // z = 7，先加后用

关系与逻辑运算符（返回 boolean）：全部列出来，按优先级从高到低：

优先级	运算符	说明
1	!	逻辑非
2	< > <= >=	关系比较
3	== !=	相等判断
4	&	与（不短路）
5	^	异或
6	\|	或（不短路）
7	&&	与（短路）
8	\|\|	或（短路）

vs C 的核心差异：&& 和 || 只能操作 boolean，没有 C 里「非 0 即真」那一套，if (1) 直接编译错误。短路：&& || 左边能决定结果时右边不会执行；& | 不短路，两边都会算。

三目运算符：条件 ? 值1 : 值2，与 C 一致：

1
int max = (a > b) ? a : b;

switch：传统写法和 C/C++ 差不多（会 fall-through，记得 break），Java 支持 4 种用法，逐一来看：

1
// ① 整数 / 字符：传统写法，会贯穿，记得 break
2
int day = 2;
3
switch (day) {
4
    case 1:
5
    case 2: System.out.println("工作日"); break;
6
    case 6:
7
    case 7: System.out.println("周末"); break;
8
    default: System.out.println("非法");
9
}
10

11
// ② 字符串（Java 7+）
12
String fruit = "apple";
13
switch (fruit) {
14
    case "apple":  System.out.println("苹果"); break;
15
    case "banana": System.out.println("香蕉"); break;
16
    default:       System.out.println("未知");
17
}
18

19
// ③ 枚举
20
enum Color { RED, GREEN, BLUE }
21
Color c = Color.GREEN;
22
switch (c) {
23
    case RED:   System.out.println("红"); break;
24
    case GREEN: System.out.println("绿"); break;
25
    case BLUE:  System.out.println("蓝"); break;
26
}
27

28
// ④ switch 表达式（Java 14+）：箭头写法，不贯穿，整体可作为表达式
29
int month = 4;
30
int days = switch (month) {
31
    case 2 -> 28;
32
    case 4, 6, 9, 11 -> 30;
33
    default -> 31;
34
};

展开收起

要点：①②③是语句（执行完就完事），④是表达式（能整体返回一个值赋给变量）；前三者会贯穿，④的箭头写法天然不贯穿。箭头分支只有一句表达式时，直接写在 -> 后面就是返回值；要写多句话就用 { } 块，块内必须用 yield 给出值：

1
int days = switch (month) {
2
    case 2 -> 28;
3
    default -> {
4
        System.out.println("走默认分支");
5
        yield 31;   // 块内用 yield 返回值
6
    }
7
};

位运算：& | ^ ~ << >> >>>。操作数是整数时是位运算；操作数是 boolean 时，& | ^ 退化为逻辑运算（不短路）。

右移有 C/C++ 没有的明确行为：

>> 算术右移，高位补符号位
>>> 无符号右移，高位补 0

C/C++ 对有符号数的右移是实现定义（不同编译器可能补符号位或补 0），Java 用 >> / >>> 明确区分，消除了这种不确定性。

括号与优先级：Java 的运算符优先级和 C 基本一致（() 最优先，* / % 高于 + -，然后是移位、关系、逻辑、赋值）。拿不准就加括号，可读性永远第一，记优先级可维护性差。

3.6 字符串#

子串：substring(a, b) 提取子串（左闭右开）；C 没有直接等价物（只能指针 + 长度模拟）
拼接：+ 直接拼字符串，任何类型和字符串 + 都会自动转成字符串：

1
String s = "Hello " + 123;   // "Hello 123"

按分隔符拼一组字符串用 String.join：

1
String csv = String.join(", ", "a", "b", "c");   // "a, b, c"

"str".repeat(n)（Java 11+）重复字符串 n 次，方便方法，知道即可。

字符串不可变：String 一旦创建就不可改变，所有”修改”（拼接、replace、substring）都是创建新字符串对象，旧对象留给垃圾回收。好处是安全、可共享、天然线程安全；代价是每次修改都有开销——这就是第 9 条要用 StringBuilder 的原因。

手感：C++ 的 std::string 可变，且有操作符重载（== 比内容、[ ] 访问），Java 没有操作符重载，一律走方法（.equals()、.charAt()），所以初看不如 C++ 直观。这是设计取舍：Java 用统一的方法调用换来了简单一致的模型。

检测字符串是否相等：内容相等用 equals，忽略大小写用 equalsIgnoreCase。不能用 ==——== 对引用比较的是”是不是同一个对象”，不是内容：

1
String a = "hello";
2
String b = new String("hello");
3
a.equals(b)      // true，内容相等
4
a == b           // false，两个不同的对象
5

6
String c = "hello";
7
a == c           // true：字面量被"驻留"到常量池，指向同一对象

最后这个例子是个陷阱：字符串 字面量（常量） 会被驻留（intern）到常量池，所以两个字面量 == 碰巧相等。但驻留只对字面量和编译期常量生效，运行时生成的新字符串不会自动共享：

1
String d = "he" + "llo";   // 编译期常量折叠 → 仍是字面量，和 a 同一个对象
2
String x = "he";
3
String y = x + "llo";      // 运行时拼接 → 新对象，和 a 不同
4
a == d                     // true
5
a == y                     // false

所以任何依赖 == 判断内容的做法都是侥幸，内容判断一律用 equals，养成习惯。对比 C：C 用 strcmp 才比内容，Java 把”比内容”（equals）和”比身份”（==）拆成两个操作，反而更明确。

空串与 null 串：""（空串，有对象、长度 0）和 null（没有对象）是两回事：

1
String empty = "";
2
String nothing = null;
3

4
empty.length() == 0    // true
5
nothing.length()       // 抛 NullPointerException！

判空用 str.isEmpty() 或 str.length() == 0；判 null 用 str == null。两个都要防时，先判 null 再判空（&& 短路保证安全）：

1
if (str != null && !str.isEmpty()) {
2
    // 既不是 null 也不是空串
3
}

null 可以类比 C++ 的 nullptr：表示引用没指向任何对象；它不是对象，所以对 null 调方法会抛 NullPointerException。 6. 码点与代码单元：length() 数的是 UTF-16 代码单元（char）个数，charAt(i) 取第 i 个 char；codePointCount(a, b) 数的是码点（真实字符）个数，codePointAt(i) 取第 i 个位置的码点：

1
String s = "A😀B";
2
s.length()                       // 4：A + 代理对(占 2 个 char) + B
3
s.codePointCount(0, s.length())  // 3：A、😀、B 三个真实字符

普通文本遍历用 for + charAt 遍历就够；要正确处理 emoji 这类增补字符才需要码点方法。codePoints() 会返回码点流，在 Stream API 的范畴再展开讲。

String API：不用背。Java 标准库方法成千上万，没人全记得住。要做的是：

记住高频的几个：length charAt substring indexOf equals equalsIgnoreCase isEmpty toUpperCase replace
其余靠 IDEA 补全（敲 str. 自动弹）+ 查文档，用多了自然熟

阅读联机 API 文档：Java 标准库的官方文档就是 Oracle 维护的 javadoc，后端开发也查它（docs.oracle.com 搜 java 17 api）。IDEA 里把鼠标悬停在类/方法上，或按 Ctrl+Q（Mac 是 Ctrl+J）直接看说明，不用每次开浏览器。
构建字符串：大量拼接别用 +（每次都会 new 一个新 String），改用 StringBuilder：

1
StringBuilder builder = new StringBuilder();
2
builder.append("Hello");
3
builder.append(" ");
4
builder.append("World");
5
String result = builder.toString();   // "Hello World"

顺带回答一个基础问题——类到底是什么？ 类不是”容器”，是图纸（模板）：它规定了对象长什么样（字段）和能干什么（方法）。StringBuilder 是一个类，new StringBuilder() 是按图纸造出一个对象，builder.append(...) 是调用这个对象的方法。一张图纸可以造出无数个对象，每个对象是独立的一份”实物”。这会在对象与类下一章细说。

文本块（Java 15+）：用 """ 包起来的多行字符串，写 HTML / JSON / SQL 不用再拼一堆 \n：

1
String html = """
2
    <html>
3
        <body>你好</body>
4
    </html>
5
    """;

两个注意点：

内容里的单个 " 不用转义，只有会影响到结束定界符 """ 时才需要 \"
行尾放一个 \ 表示忽略这个换行（\ 不进入字符串）

3.7 输入与输出#

读取输入：从标准输入读数据，用 java.util.Scanner。注意 System.in 不是包，它是 System 类里的一个静态字段，代表标准输入流（对应 C 的 stdin）；Scanner 负责把流里的字节解析成你要的类型：

1
import java.util.Scanner;
2
//`java` 顶级包 → `util` 子包 → `Scanner` 类
3
Scanner in = new Scanner(System.in);
4
String name = in.nextLine();    // 读一整行
5
int age = in.nextInt();         // 读一个整数
6
double score = in.nextDouble(); // 读一个双精度浮点数

对比 C：scanf 靠格式串 + 取地址符，类型不匹配很容易出问题；Scanner 的方法是类型化的（nextInt() 保证返回 int），更安全但略啰嗦。还有 next()（读一个单词）、hasNextInt()（先判断下一个是不是整数）等。

另外还有 java.io.Console（System.console() 获取），适合交互式控制台场景（如读密码不回显）；但它在 IDE/重定向环境下可能拿不到，普通场景用 Scanner 就够。

格式化输出：和 C 的 printf 几乎一模一样——Java 直接把格式串机制搬了过来：

1
System.out.printf("%d %f %s%n", age, score, name);

对应 C 的 printf("%d %f %s\n", age, score, name);，占位符 %d %f %s 完全一致。完整格式串语法是：

1
%[参数索引$][标志][宽度][.精度]转换符

部分	含义
`%`	格式串起始符
`参数索引$`	指定用第几个参数（如 `%1$d` 用第 1 个参数）
`标志`	对齐、符号、补零等控制
`宽度`	最小输出宽度，不足补空格或 0
`.精度`	浮点 = 小数位数；字符串 = 最大长度
`转换符`	决定输出格式与接受类型

全部标志：

标志	作用	示例	输出
`-`	左对齐（默认右对齐）	`printf("%-5d", 12)`	`12`
`+`	正数带 `+` 号	`printf("%+d", 12)`	`+12`
`0`	数字前补 0	`printf("%05d", 12)`	`00012`
`空格`	正数前留一个空格	`printf("% d", 12)`	`12`
`(`	负数用括号包起来	`printf("%(d", -12)`	`(12)`
`,`	千位分隔符	`printf("%,d", 1234567)`	`1,234,567`
`#`	备选形式（如 `0x` 前缀）	`printf("%#x", 255)`	`0xff`
`$`	参数索引结束符：`%2$d` 用第 2 个参数，可重排/复用	`printf("%2$s %1$s", "a", "b")`	`b a`
`<`	复用上一个格式符的参数	`printf("%d %<x", 255)`	`255 ff`

全部转换符：

转换符	含义	适用类型	示例（对 42）
`%d`	十进制整数	byte / short / int / long / BigInteger	`42`
`%o`	八进制整数	同上	`52`
`%x` `%X`	十六进制整数	同上	`2a`
`%f` `%F`	十进制浮点	float / double / BigDecimal	`3.140000`
`%e` `%E`	科学计数法	同上	`3.140000e+00`
`%g` `%G`	通用浮点（自动选 f 或 e）	同上	`3.14000`
`%a` `%A`	十六进制浮点数	float / double / BigDecimal	`0x1.0p-1`（对 0.5）
`%s` `%S`	字符串	String / 任意对象	`hello`
`%c` `%C`	字符	char / byte / short / int	`A`
`%b` `%B`	布尔（`%B` 输出大写）	boolean	`true` / `TRUE`
`%h` `%H`	散列码	任意对象	`5e9a2c`
`%n`	平台换行	—	换行
`%%`	字面量百分号	—	`%`
`%tx` `%Tx`	日期时间（必须跟后缀，如 `%tY` 年份）	long / Long / Date / Calendar	`2026`

%t 单独写不合法，它是日期时间的”前缀”，后面必须跟一个字母指定取哪部分：%tY 年、%tm 月、%td 日、%tH 时（24 小时制）、%tM 分、%tS 秒、%tF 完整日期 yyyy-MM-dd、%tT 完整时间 HH:mm:ss。

几个注意点：

%n 输出平台原生行分隔符。C 的 printf("\n") 在 Windows 文本模式下会自动转成 \r\n，但 Java 的 \n 永远是 LF、不做转换，想要平台分隔符就用 %n
String.format(...) 是 Java 版的 sprintf：格式化后返回字符串而不打印
类型必须匹配：%d 配 String 直接抛异常——C 是未定义行为，Java 把错误拦在运行时
System.out.printf 与 System.out.format 完全等价

文件输入与输出：套路和标准输入输出一模一样，只是把 System.in 换成文件路径。

读文件用 Scanner，传一个 Path：

1
Scanner in = new Scanner(Path.of("data.txt"), StandardCharsets.UTF_8);
2
while (in.hasNextLine()) {
3
    System.out.println(in.nextLine());
4
}

写文件用 PrintWriter：

1
PrintWriter out = new PrintWriter("output.txt", StandardCharsets.UTF_8);
2
out.println("Hello 文件");
3
out.close();   // 写完必须关，否则可能没落盘

对比 C 的 FILE*：C 是 fopen("file.txt", "r") + fscanf / fprintf，Java 是把文件包进 Scanner / PrintWriter 对象再读写——同样是面向对象的”构造对象、调方法”套路。

相对路径：相对的是 JVM 的工作目录（启动 java 命令时所在的目录），不是 .java / .class 文件所在的目录。在 IDEA 里默认是项目模块目录，容易和直觉不符——报 FileNotFoundException 时，先想想”当前工作目录到底在哪”。

两个注意点：

编码：建议显式传 StandardCharsets.UTF_8，否则用平台默认编码，跨机器容易乱码
关闭：用完要 close()，否则数据可能没写入磁盘、句柄泄漏（后面 ⑩ 文件 IO 会讲 try-with-resources 自动关闭）

3.8 控制流程#

块作用域：和 C 一样，变量在声明它的 { } 块内有效。唯一区别在 3.4 提过：Java 不允许内层块遮蔽外层同名变量。

条件语句：if / else if / else 与 C 完全一致，唯一区别是条件必须是 boolean（if (1) 编译错误）。

循环：while、do-while、for 和 C 一模一样：

1
while (条件) { ... }
2
do { ... } while (条件);
3
for (int i = 0; i < n; i++) { ... }

for 里声明的 int i 只在循环内有效，这点和 C99 之后一致。switch 已在 3.5 讲过，不重复。

中断控制流程：break 跳出当前循环/switch；continue 跳过本次循环剩余部分、进入下一轮。Java 还有 C 没有的带标签的 break/continue，专治多层嵌套循环：

1
outer:
2
for (int i = 0; i < 3; i++) {
3
    for (int j = 0; j < 3; j++) {
4
        if (j == 1) break outer;   // 跳出整个外层循环，执行它后面的语句
5
    }
6
}

带标签的 continue 则跳到外层循环的下一次迭代：

1
outer:
2
for (int i = 0; i < 3; i++) {
3
    for (int j = 0; j < 3; j++) {
4
        if (j == 1) continue outer;   // 直接开始外层下一轮 i
5
        System.out.println(i + "," + j);
6
    }
7
}
8
// 输出：0,0 / 1,0 / 2,0

	`break outer`	`continue outer`
行为	退出整个外层循环（不再执行）	跳到外层循环下一次迭代
类比	循环直接结束	外层跳过这一轮，继续

对比 C：C 想跳出多层循环只能靠 flag 标志位或 goto。Java 把 goto 留作保留字但禁用（怕 goto 把结构搅成”意大利面条式代码”），用带标签的 break/continue 作为结构化替代——能跳出/跳过多层循环，但跳转方向被限制在循环的进出，不会乱跳。

带标签的 break 还能用在普通块上（不限于循环）——这是很实用的”提前退出嵌套逻辑”手法：

1
outer:
2
{
3
    if (条件A) {
4
        if (条件B) {
5
            break outer;   // 满足条件，块里剩余代码全部跳过
6
        }
7
        //这里是代码
8
    }
9
    System.out.println("条件不满足时才执行到这里");
10
}

等价于 C 里用 goto 提前跳出，但只允许”从块内退出”，方向被限定，不会乱跳。

最后一条硬性规则：break / continue 只能跳到”包着它”的标签——标签标记的语句必须在词法上包含当前语句。站在块里面才能”跳出去”，站在外面就不能”跳出”这个块，编译器直接报错：

1
outer:
2
{
3
    break outer;   // ✅ 合法：break 在块内部
4
}
5
break outer;       // ❌ 编译错误：已经在块外面了

这一节最容易踩的坑（都是相对 C 的新东西）：

continue 会跳过循环体里的更新语句——for 安全（i++ 在循环头部，continue 跳回时自动执行）；while 危险（更新写在循环体里，continue 直接跳回条件判断，把更新跳过了 → 可能死循环）
带标签的 continue 不保存状态——跳到外层循环的下一轮，内层循环整体作废、从零开始，不会”接着上次”
标签类型有限制——continue 的标签必须标在循环上；break 的标签可以是循环/块/switch。标错当场编译报错
break outer 跳到标签块之后，不是跳到标签那一行

3.9 大数#

C 没有原生大数：long 上限也就 ±9.2×10¹⁸。Java 提供两个类处理超出范围的数：

BigInteger：任意精度整数
BigDecimal：任意精度小数（适合金额，避免浮点误差）

不能直接用 + - * / 运算符，要调方法：

1
BigInteger a = BigInteger.valueOf(1234567890);
2
BigInteger b = BigInteger.valueOf(9876543210L);
3
BigInteger sum = a.add(b);          // 加
4
BigInteger diff = a.subtract(b);    // 减
5
BigInteger prod = a.multiply(b);    // 乘
6
BigInteger quo = a.divide(b);       // 除

构造要点：

小数值用 BigInteger.valueOf(long) 转换
超大数用字符串构造：new BigInteger("123456789012345678901234567890")——直接写数字字面量会因超出 long 范围编译报错

BigDecimal 常见于金额计算。0.1 + 0.2 用 double 算出来是 0.30000000000000004，用 BigDecimal 精确：

1
BigDecimal d = BigDecimal.valueOf(0.1).add(BigDecimal.valueOf(0.2));
2
// 结果是精确的 0.3

坑：用 BigDecimal.valueOf(0.1) 才是精确的 0.1；new BigDecimal(0.1) 会把 double 的二进制近似值原样带进去，反而”不精确”。

3.10 数组#

声明与初始化：数组是对象，声明只是引用，必须 new 才有实体：

1
int[] a = new int[10];           // 10 个元素，默认 0
2
int[] b = { 1, 2, 3, 4, 5 };     // 花括号直接初始化，不用 new
3
int[] c = { 1, 2, 3, 4, 5, };    // 允许最后位置有逗号

vs C：int a[10] 声明即分配，Java 必须 new。

匿名数组与空数组：new int[] { 1, 2, 3 } 是匿名数组，不赋给变量，直接传给方法用：

1
int sum = sum(new int[] { 1, 2, 3 });   // 匿名数组做参数

new int[0]（或 new int[] {}）是长度为 0 的数组——合法且有用：方法没结果时返回空数组而不是 null，调用方就不用判空了。

数组长度固定，但引用可以换：数组对象一旦创建长度就定死，但变量只是个引用，可以随时指向新数组——这就是”声明和构造分离”的灵活性：

1
int[] a;          // 声明：只是引用，没分配内存
2
a = new int[10];  // 构造
3
a = new int[20];  // 换个更大的（旧数组交给垃圾回收）

要”换大小还保留内容”用 Arrays.copyOf(a, 新长度)（自动拷贝并补零/截断）。对比 C：C 里 int a[10] 声明即定死，想换只能手动 malloc + memcpy + free，还得自己管内存——Java 的”引用可换 + GC 回收”灵活得多。

访问与长度：下标从 0 开始；a.length 是属性（不是函数，C 得 sizeof(a)/sizeof(a[0]) 自己算）。越界抛 ArrayIndexOutOfBoundsException——C 越界是未定义行为，Java 直接拦下来。

for each 循环：遍历数组的简写：

1
for (int x : b) {
2
    System.out.println(x);
3
}

等价于 C 的下标遍历。注意拿到的是元素副本，改 x 不影响原数组；想改元素就用传统 for 加下标。

数组拷贝：= 赋值只是复制引用（两个变量指向同一个数组，改一个另一个也变）；要独立副本用 Arrays.copyOf：

1
int[] same = b;                           // 只是多一个引用，同一数组
2
int[] copy = Arrays.copyOf(b, b.length);  // 深拷贝，新数组
3
int[] first3 = Arrays.copyOf(b, 3);       // 只拷前 3 个

数组排序：Arrays.sort(a) 一行升序排序——C 要么手写排序要么 qsort。

命令行参数：main(String[] args) 对应 C 的 argc/argv。Java 不传 argc（用 args.length），且 args[0] 是第一个用户参数（C 的 argv[0] 是程序名）：

1
public static void main(String[] args) {
2
    System.out.println(args.length);  // 参数个数
3
    System.out.println(args[0]);      // 第一个参数
4
}

多维数组：本质是”数组的数组”。声明 int[][] grid = new int[3][4];，访问 grid[i][j]。

不规则数组（Java 的优势）：每一行长度可以不同，C 的多维数组必须是矩形，Java 可以”锯齿”：

1
int[][] triangle = new int[5][];
2
for (int i = 0; i < 5; i++) {
3
    triangle[i] = new int[i + 1];   // 第 i 行 i+1 个元素
4
}

C 想实现不规则数组得用”指针数组 + 手动管理”，Java 天然支持。

附录#

日期#

java.time 的 LocalDate（不可变日期类）：

1
import java.time.LocalDate;
2

3
LocalDate today = LocalDate.now();          // 今天
4
LocalDate bday = LocalDate.of(2000, 1, 1);  // 指定日期
5

6
bday.plusDays(100);       // 100 天后（返回新对象，原对象不变）
7
bday.getDayOfWeek();      // 星期几
8
bday.until(today);        // 距离今天多少天

和 String 一样，LocalDate 是不可变的：plusDays 返回新对象，不会改原来的。

对比 C：C 标准库没有好用的日期类型（time_t 是秒数，得自己转格式），Java 的 java.time 开箱即用。

小结：Java vs C 对照表#

维度	C	Java
程序结构	自由函数 + main	万物皆类，main 在类内
编译运行	`gcc` → 可执行文件 → CPU 直接跑	`javac` → 字节码 → JVM（解释 + JIT）
内存	手动管理（malloc/free）	自动垃圾回收
整型大小	随平台（int 可能是 2/4 字节）	固定（int 永远 4 字节）
无符号数	有 unsigned	没有（唯一”无符号”的 char 不做算术）
字符串	`char*` / `char[]`	`String` 对象，不可变，`equals` 比内容
数组	下标遍历，`sizeof` 求长	对象，`length` 属性，for-each，越界抛异常
输入输出	`scanf` / `printf` / `FILE*`	`Scanner` / `System.out.printf` / `PrintWriter`
大数	无原生支持	`BigInteger` / `BigDecimal`
布尔	0 / 非 0 当真假	只有 `true`/`false`，`if (1)` 报错
内存安全	野指针、越界家常便饭	引用不能算数，越界即异常
等等

本章收获：C 给你完全控制权（和一堆踩坑机会），Java 帮你管好内存与边界，换来跨平台与安全。 学完这一章，可以用 Java 写出任何 C 能写的基础程序了。

蜂窝版 MacBook：80 块钱让 Mac 直插 4G 卡上网 + 保号接码

Tue, 25 Aug 2026 00:00:00 GMT

一颗大疆无人机拆机的 4G 模块，一条 AT 指令，让你的 MacBook 变成「蜂窝版」——既能独立 4G 上网，还能跑 VoHive 平台控制sim卡接码等功能。全程软件成本 0 元。

写在前面：这不是「破解」，是「切换」#

很多人看到「大疆模块改 EC25」以为是什么高深破解。其实一句话就能讲完：

大疆 4G 模块（一代）本质是移远 Quectel EG25-G，但出厂被大疆写成了私有 USB 身份（VID/PID 2ca3:4006），通用驱动不认。我们要做的，只是发一条厂商本来就支持的 AT 配置指令，把它的 USB 身份从大疆改回标准的移远 EC25（2c7c:0125）：

1
AT+QCFG="usbcfg",0x2C7C,0x0125,1,1,1,1,1,0,0

没有刷固件、没有破解加密、没有改 Mac 任何系统文件——芯片本来就会变多种身份，我们只是让它换回标准的那套。改一次，写进模块 NVRAM，终身有效。

为什么是这颗模块#

便宜：大疆无人机拆机件。最早 3040 元，火了之后被炒到 80 元左右，但依然比一颗全新的移远 EC25（100200 元）便宜。
本质是移远 EG25-G：高通平台，LTE Cat 4，标准 AT 指令集齐全。
被大疆「封印」了身份：所以便宜，也所以要改。

代价是它默认的 USB 身份和模式都不是「标准」的，得手动改一次。

我要实现的两个目标#

Mac 独立 4G 上网（学校WIFI你懂得，不想天天开手机热点）
海外卡保号 / 接码（用 VoHive 平台收发短信、看 SIM 状态，甚至以后做 VoWiFi ）

这两个目标对应模块的两种工作模式，不可兼得：

模式	模块在哪	用途
ECM（`usbnet=1`）	Mac	4G 上网（macOS 原生认）
QMI（`usbnet=0`）	虚拟机	VoHive 接码/保号

这就是后面所有折腾的根源：一颗模块、一根 USB，一次只能干一件事、待在一个地方。

材料清单#

项	成本
大疆 4G 模块（一代）	~80 元
一张有流量的 SIM 卡	自备
UTM（虚拟机）	免费
Ubuntu Server 24.04 arm64	免费

第一步：让 Mac 能上网（改 ID + 切 ECM）#

这一步是一次性的，做完以后模块插上 Mac 就是网卡。

核心就是在 Linux 环境（UTM 虚拟机）里，用 socat 往串口发两条指令：

Terminal window

1
# 改身份：大疆 2ca3:4006 → 移远 2c7c:0125
2
AT+QCFG="usbcfg",0x2C7C,0x0125,1,1,1,1,1,0,0
3
# 切模式：QMI(0) → ECM(1)，macOS 才能认
4
AT+QCFG="usbnet",1
5
# 软重启生效
6
AT+CFUN=1,1

模组重启后弹回 Mac，macOS 原生驱动 AppleUSBECM 直接把它认成一张 USB 网卡，自动拨号（APN cmnet）后就能上网了。

第二步：部署 VoHive（保号/接码）#

VoHive 是面向高通 4G 模组的管理平台，网页端收发短信、看信号、管 eSIM。

这里有个重要的坑：VoHive 上游项目已经无限期停维护了，官方 release 的二进制全被清空（最后的 v9.9.9 是 12 字节的告别占位符）。arm64 的二进制只能去 fork 里挖——我花了点功夫，从三个字节完全一致的 fork 里找回了一份，并交叉验证了 sha256。

踩坑记录（这才是真干货）#

这套东西的教程网上很多，但实测和教程对不上的地方不少，逐个锤下来：

usbnet 映射教程写错了：有篇笔记说 usbnet=2 是 ECM，实测这颗模块 2 是 MBIM、1 才是 ECM。照抄 2 会导致 Mac 死活拿不到网卡。
UTM 的命令行直通是坏的：utmctl usb connect 报 -2700「找不到设备」。翻源码发现是 UTM 对「复合设备」（一个 VID/PID 下面挂多个接口）的匹配 bug，GUI 直通走的是另一条路径所以能通——直通只能手动点。
模组会休眠：AT 口闲置一段时间就睡着，前 1~2 次发 AT 唤不醒，要发到第 3 次才回 OK。所以脚本里找 AT 口必须带重试。
stale 文件坑：往串口写指令时如果设备节点刚好不存在，tee 会在 /dev 下误建一个普通文件，挡住真正的设备节点。得先清掉再 mknod 重建。

最终成果#

三个 shell 脚本 + 一个菜单命令，全在 PATH 里：

Terminal window

1
vohive    # 进入菜单，选 1 保号 / 2 上网 / 3 状态

命令	作用
`vohive` → 1	切保号（QMI / VoHive）
`vohive` → 2	切上网（ECM / Mac 蜂窝）
`vohive` → 3	查状态

结语#

从「一颗插上什么都不认的大疆私有模块」到「Mac 的 4G 网卡 + 保号平台」，总成本不到 100 元。核心认知就一句：这不是破解，是让芯片换回它本来的标准身份。 教程不可靠的地方，实测永远能锤出真相。

通信技术基础：先把这些名词搞懂#

这篇文章的重点其实是借这颗 80 块的模块，把移动通信的底层概念讲清楚。下面按「网络 → 频段 → 身份 → 接口 → 实用功能」的顺序，把文中涉及的所有名词一次补齐。看不懂的实操细节，都能在这里找到答案。

一、什么是 LTE#

LTE（Long Term Evolution，「长期演进」）就是俗称的 4G。 名字本身没有「第四代」的意思，只是 3GPP 给这套标准起的代号——因为它是从 3G（UMTS/WCDMA）一路「长期演进」过来的。

手机通信的「代」是这样排的：

代	技术	能干什么
1G	模拟（AMPS 等）	只能打电话
2G	数字 GSM	打电话 + 短信 + 极慢速上网
3G	UMTS / WCDMA / CDMA2000	能真正上网了
4G	LTE	纯 IP 网络，快
5G	NR	更快、更低时延

LTE 的核心变化是彻底 IP 化：把 2G/3G 那套「电路交换」（打电话专用线路）拆掉，语音、数据全部变成 IP 包。正因如此，4G 时代「打电话」要靠 VoLTE（Voice over LTE，走 IMS 的语音），而不是老线路。

LTE 内部又按能力分 Cat（Category，类别）：Cat 1、Cat 4、Cat 6……数字越大越快。这颗 EG25-G 是 Cat 4：下行最高 150 Mbps、上行 50 Mbps，日常上网、刷视频完全够用。

一句话：LTE = 4G 的标准名；Cat 4 = 这颗模块的「档位」。

二、频段（Band）和频率的关系#

这是新手最容易混的一对概念。

频率：无线电波的物理频率，单位 Hz。比如 1800 MHz、2100 MHz——这是真实存在的物理量。
频段（Band）：3GPP 给每段可用频率统一编了号，比如 Band 3 = 1800 MHz、Band 1 = 2100 MHz、Band 8 = 900 MHz、Band 40 = 2300 MHz。这个编号就是「Band」。
关系：Band 是频率的标准化标签。 说「支持 Band 3」，意思就是「支持 1800 MHz 附近那一段」。

为什么要搞 Band 编号？因为同一个频率范围，各国运营商拿到手的「切片」不一样（上下行差多少、带宽多宽），用编号能精确指代「这一整段」，而不只是「中心频率」一句话。

另外，移动网络大多是 FDD 双工（见下一节）：上行和下行用不同的频率，所以一个 Band 里同时定义了上行段和下行段。比如 Band 3：

上行（手机 → 基站）：1710–1785 MHz
下行（基站 → 手机）：1805–1880 MHz

模块支持的 Band 越多，跨国漫游越稳。EG25-G 标称支持包括国内 B1/B3/B5/B8/B39/B40/B41 在内的多种 FDD + TDD 频段。

三、信道（Channel）#

如果说 Band 是「一整段马路」，信道就是这条马路上划出的一条具体车道。

在 Band 内部，运营商会把频率再切成一个个更窄的「信道」，每个信道一个中心频率、一个编号。
GSM 时代的信道编号叫 ARFCN，LTE 时代叫 EARFCN。手机/模块「搜网」时，就是在逐个扫描信道，看哪个上面有基站的广播信号。
日常使用你几乎不用直接跟信道打交道——模块会自动扫信道、选信道。但当你用工具看「当前驻留的频点」时，看到的那串数字（EARFCN）就是信道编号。

四、FDD 与 TDD：中国和外国的「通信模式」#

这里要澄清一个常见误解：「FDD / TDD」不是「中国模式 vs 外国模式」，而是移动网络最底层的「双工（Duplex）方式」——即「上下行怎么错开，避免自己发出的信号撞上自己收到的信号」。

FDD（频分双工）：上行、下行用两条不同频率，同时进行。像一条双向八车道——去的车走左边、来的车走右边，互不干扰。全球绝大多数 4G 网络、欧美日韩的主流，都是 FDD。
TDD（时分双工）：上行、下行用同一条频率，靠时间轮流切换。像单行道按红绿灯交替放行——这一瞬只发、下一瞬只收。省频谱，但需要精确的时钟同步。

那「中国」特殊在哪？——中国三大运营商是 FDD 和 TDD 混着用的：

运营商	4G 主力制式
中国移动	TDD（Band 38/39/40/41）为主
中国联通	FDD（Band 1/3）为主
中国电信	FDD（Band 1/3/5）为主

（后来三家也都拿到了对方制式的牌照，但历史主力如上。）

所以「中国 FDD」这个说法要拆开看：电信、联通走 FDD，移动走 TDD。 而这颗 EG25-G 频段覆盖够全，FDD / TDD 都支持，插哪家卡都能用——这就是「多频多模」的意思。

顺带一提，「外国」并不构成一个统一模式：欧美主流是 FDD，日本部分运营商也用 TDD。真正该记的维度是 FDD vs TDD，而不是「中国 vs 外国」。

五、三张身份证：IMEI / ICCID / IMSI#

移动网络里最容易搞混的三个 ID，恰好分别对应「设备 / 卡 / 用户」三个东西：

	全称	位数	标识谁	读取方式
IMEI	国际移动设备识别码	15 位	设备（这台模块）	`AT+CGSN`
ICCID	集成电路卡识别码	19~20 位	SIM 卡（那张塑料卡）	卡面印着 / `AT+QCCID`
IMSI	国际移动用户识别码	15 位	用户/账户（运营商开的户）	存 SIM 里 / `AT+CIMI`

拆开讲：

IMEI：设备的身份证。厂家出厂烧进去，标识这台硬件唯一。丢手机可以去运营商报失，按 IMEI 把设备拉黑变砖。这颗模块的 IMEI 也能改（AT+EGMR），那是另一个话题。
ICCID：SIM 卡的身份证。每张卡出厂就印了唯一编号，直接印在卡面上那串长数字就是。换卡 = 换 ICCID。
IMSI：账户的身份证。格式 = MCC（国家码，3 位，中国 460）+ MNC（运营商码，2~3 位，移动 00 / 联通 01 / 电信 03，各自还有备用码）+ MSIN（用户号）。网络靠它判断「你是谁、该用谁的套餐」。

一句话记法：IMEI 认设备，ICCID 认卡，IMSI 认人。 换卡不换机，IMSI/ICCID 变、IMEI 不变；换机不换卡，IMEI 变、IMSI/ICCID 不变。

六、模块的四种「工作模式」#

模块和电脑靠 USB 相连，但「USB 上跑什么协议、数据以什么形态出来」有几种可选。这就是 AT+QCFG="usbnet",x 里那个 x 的含义。这颗 EG25-G 支持这四种（usbnet 的取值）：

usbnet	模式	全称	出来的是	谁在用
0	QMI	Qualcomm MSM Interface	高通私有二进制接口	Linux / ModemManager
1	ECM	Ethernet Control Model	一张标准「USB 网卡」	macOS 原生认（本文上网用）
2	MBIM	Mobile Broadband Interface Model	现代 USB 宽带标准接口	Windows 10+ / 新版 Linux
3	RNDIS	Remote NDIS	微软风格的「USB 网卡」	老 Windows / Android

关键区别：

ECM / RNDIS / MBIM 这三类，模块会把蜂窝网络「伪装成一张以太网卡」交给电脑。电脑不用懂 4G，只要会认网卡、会 DHCP 拿 IP 就能上网。区别只在「伪装手法」：ECM 是通用标准（macOS 认），RNDIS 是微软家的，MBIM 是最新最规范的通用标准。
QMI 不是网卡，而是高通芯片的原生控制接口（二进制协议）。它比「网卡」暴露得更多、控制力更强，所以 VoHive 这类要深度管理模块的平台走 QMI。

这就是「一颗模块一次只能选一种身份」的原因：选了 ECM 就是「网卡」，选了 QMI 就是「管理接口」，两者不能同时是。（另外还有一堆 ttyUSB 串口是 AT 命令口，见下——它们与这四种「数据模式」并存，不冲突。）

七、两种「管理模式」：AT 和 QMI——你怎么指挥这颗芯片#

上一节讲「数据怎么出来」，这一节讲「你怎么命令它」。有两套截然不同的「遥控器」：

	AT 命令	QMI
形态	文本指令，人可读	二进制协议，机器读
通道	串口（某个 `ttyUSB`）	USB 的 `cdc-wdm` 设备
例子	`AT+CSQ` 查信号、`AT+QCFG` 改配置	libqmi 库 / ModemManager 调用
优点	简单、通用、能手敲	强大、结构化、能做的事多
谁用	我们（脚本里 `socat` 发的那几条）	VoHive、ModemManager

AT 命令：脱胎于老式调制解调器的「Hayes 指令集」，一行行 AT+... 文本。开头那两条 AT+QCFG 就是 AT 命令。它几乎成了所有蜂窝模组的「通用普通话」——别看形式简单，能做的事其实极多：ATD10086; 拨号打电话、ATA 接电话、ATH 挂电话、AT+CMGS 发短信、AT+CNMI/AT+CMGR 收/读短信、AT+CSQ 查信号、AT+CUSD 拨 USSD、AT+VTS 发 DTMF……整颗模组从打电话到收发短信，几乎每个动作都能用一行文本命令搞定。它唯一的「限制」是形式：一次一条、逐条来。
QMI：高通芯片的私有二进制接口，功能远强于 AT——能并发、结构化地读网络状态、注册事件监听、管理数据通路。代价是复杂，得靠 libqmi 这类库调用，人没法手敲。

本文「改身份、切模式」用 AT（一次性配置），「日常接码管理」用 QMI（VoHive 内部），正好体现分工：AT 做一次性配置，QMI 做持续管理。

八、APN 是什么#

APN（Access Point Name，接入点名称）= 你接入互联网时经过的那个「运营商网关」的名字。

手机网络的出口不直接通公网，而是先经过运营商的一个网关。这样的网关有很多个，各干各的活：

上网流量 → 走「互联网 APN」（移动 cmnet、联通 3gnet、电信 ctnet）
彩信 MMS → 走「彩信 APN」（cmwap 之类，现在基本淘汰）
VoLTE/IMS 语音 → 走「IMS APN」（ims）

APN 就是告诉模块：「我要上网，请把我接到叫 cmnet 的那个网关去。」配置里一般还附带用户名/密码（很多国内 APN 是空的）和鉴权方式。

文章里「自动拨号（APN cmnet）」指的就是：模块建立数据连接时，自动用移动的 cmnet 这个 APN 接入互联网。

九、USSD 是什么#

USSD（Unstructured Supplementary Service Data，非结构化补充业务数据）= 你在拨号键盘按 *100# 之后弹出的那种实时代码菜单。

它是一组短代码，走的是网络的信令信道（不是普通数据/语音信道），所以：不联网也能用、几乎零延迟、实时会话式。
典型用途：查话费余额、查流量、充值、开业务。国外运营商（尤其非洲、印度）的 USSD 菜单尤其丰富，甚至用来做移动支付。
和短信 SMS 的区别：SMS 是「存储转发」的异步消息（发出去对方可能晚收到）；USSD 是「实时会话」（你一按，服务器立刻回，像打电话一样一问一答）。

在模块上，USSD 通过 AT+CUSD 发送和接收。VoHive 这类平台就是靠它触发「查余额」这类即时查询的。（具体代码各家运营商不同，*100# 只是示例。）

十、DTMF 通信是什么#

DTMF（Dual-Tone Multi-Frequency，双音多频）= 你打电话按数字键时发出的「嘟—嘟」声的正式名字。

原理：电话键盘每个键按下时，同时发出两个不同频率的正弦波（一个来自「低频组」、一个来自「高频组」），接收端根据「哪两个频率同时出现」判断按了哪个键。两个音叠加，抗干扰、可靠，所以叫「双音多频」。
一共 16 个键：0-9、*、#，外加 4 个备用键 A/B/C/D（普通人用不到）。
用途：拨号；以及打 IVR 自助语音后「请按 1 转人工」——你按的那个「1」，就是通过 DTMF 传过去的。输银行卡密码、身份证号也是 DTMF。这个过程完全由你的拨号APP完成

在模块上，DTMF 用 AT+VTS 发送（主动按一个键）、AT+DDET 接收/检测（识别对方 IVR 传来的按键）。

十一、VoWiFi 是什么#

VoWiFi（Voice over WiFi，WiFi 通话）= 不靠蜂窝信号，用 WiFi 网络打电话、发短信的技术。

传统打电话走蜂窝网络（2G/3G 电路交换，或 4G 的 VoLTE）。VoWiFi 则把语音/短信打包，通过 WiFi → 互联网 → 运营商 IMS 核心网这条隧道来传。
关键：VoWiFi 走的是运营商自家的 IMS 平台，所以用的是你的手机号、按你的套餐计费（甚至免费），对方来电看到的还是你的号码。它不是微信语音那种「App 到 App」的网络电话。
好处：蜂窝信号差（地下室、海外漫游）但 WiFi 好的地方，照样接打电话。
技术上靠 ePDG（演进分组数据网关）：手机先和运营商的 ePDG 建立一条加密的 IPSec 隧道，再在隧道里跑 IMS 语音。

文章里「以后做 VoWiFi」的意思：VoHive 这类高通模组管理平台，理论上能驱动模块走 ePDG 隧道，让这颗 4G 模块/这张卡在 WiFi 环境下也能「打电话」。这是接码保号之外的一个进阶玩法。

Markdown 入门教程：一篇就够了

Mon, 24 Aug 2026 00:00:00 GMT

Markdown 是一种轻量级标记语言，让你专注于写作内容，不能用于排版。下面是最常用的语法速查。

1. 标题语法#

使用 # 号表示标题，几个 # 就是几级标题。

一级标题#

二级标题#

三级标题#

2. 文字强调#

加粗：使用 **文字** 包裹（快捷键 Ctrl+B）
斜体：使用 *文字* 包裹（快捷键 Ctrl+I）
加粗斜体：使用 ***文字*** 包裹
删除线：使用 ~~文字~~ 包裹（表示废弃或修改）

3. 列表结构#

无序列表（使用 - 或 *）#

苹果
- 红富士（子项缩进 2 或 4 个空格）
香蕉

有序列表（使用数字加点）#

第一步
第二步
1. 子步骤

4. 链接与图片#

点击访问百度 https://www.baidu.com

这是一张示例图片

5. 代码块#

三个反引号，指定语言可以实现语法高亮。

1
System.out.println("Hello World");

TARS — 个人 AI 管家

Fri, 21 Aug 2026 00:00:00 GMT

TARS doesn’t remember you. It learns how to work with you.
不保存用户，而是持续学习用户。

这个项目暂时废了，后期准备包装成obsidina插件发布，文档方式交互。#

一、为什么做 TARS#

TARS 的名字来自《星际穿越》中的战术机器人——可靠、直接、偶尔黑色幽默，绝对忠诚。

作为一个 J 人，我一直希望有一个能辅助规划一切、提供最清晰路径的 AI。但使用现有 AI 的过程中发现一个根本问题：缺少人情味。

这种”活人感”的缺失来自哪里？经过深度思考，我认为核心是：AI 没有确定的立场。 它总是站在最普世的角度思考问题。二选一的问题，它给你”最真诚、最不绕弯子的废话”——所有人都知道收益最大化是什么，但你要的不是这个。

TARS 解决两件事：立场不对称（AI 没有你的立场）和被动性（AI 不会主动找你）。

二、什么是立场#

“屁股决定脑袋”。

你的阅历和所处环境决定了你的想法和行动。没有经历过底层互害，就不会认可社会达尔文主义。笑是你最安全的表情，可能是你对不确定性的排斥导致的。不擅长侃侃而谈，可能是因为过去这么做收益不高。所有外界刺激的总和，构成了你的性格、潜意识、表达风格、决策倾向、价值观。

这个世界上没有绝对的傻子——每个人都在自己立场的最大限度内，被多巴胺刺激做出当下最优的选择。立场是人的根本属性。

如何为 AI 赋予立场？ 提示词切换（“你是英语专家”→“你是风水大师”）恰恰说明 AI 没有确定的立场。TARS 的解决方案是：从记忆系统入手。

立场是记忆的产物。我们每天醒来还记得自己叫什么、经历过什么——立场就是从记忆中解释和抽象出来的。推理能力由大模型提供，但立场存续靠的是记忆架构。在大模型推理模式被下一代技术变革之前，记忆系统是我们实现立场模拟的核心路径。

三、记忆系统#

三种存储，各司其职#

存储	存什么	为什么
SQLite	体重/心情/睡眠（时序）、项目状态、事件日志、每日日记、任务、情绪、承诺、偏好、关系、想法、财务 — 共 30 张表	精确查询——“本周体重中位数”、“哪些项目卡住了”、“3 天没更新的指标”
Chroma 向量库	人生档案分段 + 事件摘要的语义索引	模糊回忆——“我之前提过类似的想法吗”、“大学时我是什么状态”
Markdown 文件	人生档案原文（profile/goals/timeline/worldview）	人类可读、随手能改、git 版本跟踪

三者不可互换——SQL 做不了语义检索，向量做不了精确数值查询，文件做不了结构化统计。

每次 tick 的装填过程#

TARS 不是常驻进程。每次被 macOS 快捷指令或 tars 命令”踹”一脚，Docker 容器启动，从三种存储里拼出一张 ~3500 字的上下文快照喂给 LLM：

1
tars 命令触发容器
2
  │
3
  ├─ 1. 读 Markdown 文件
4
  │     profile.md → "我是谁"
5
  │     goals.md → "我要去哪"
6
  │     worldview.md → "我戴什么眼镜看世界"
7
  │
8
  ├─ 2. 查 SQLite
9
  │     metrics → 体重/心情/睡眠最新值
10
  │     entities → stuck 项目
11
  │     events WHERE pending → 悬而未决的事
12
  │     diaries LIMIT 7 → 近一周摘要
13
  │
14
  ├─ 3. 语义检索 Chroma（基于当前任务）
15
  │
16
  ├─ 4. 拟合 Self Model（行为 vs 声明 gap）
17
  │     条件化规则（IF deadline<3天 THEN 执行力91%）
18
  │
19
  └─ 5. 拼成 system prompt → LLM

展开收起

记忆生命周期#

events 表的 lifecycle 字段控制四态流转：

1
你说"在考虑换工作"
2
  → TARS 写入: event(kind=decision, lifecycle=pending)
3

4
下次 check-in，TARS 查: SELECT * FROM events WHERE lifecycle='pending'
5
  → 主动问："换工作的事有结论了吗？"
6

7
你说"决定再待一年"
8
  → TARS 更新: UPDATE events SET lifecycle='resolved'
9
  → resolved 不再出现在"待追踪"列表
10

11
三个月后你思考职业规划
12
  → RAG 语义召回 → "三个月前你决定再待一年，现在需要重新评估吗？"

pending 留在眼前催你决断，resolved 沉入向量库等待语义召回，fact 和 preference 永远留档。 每天 200 字日记摘要提供”最近发生了什么”的最小上下文。30 天前的日记合并为月摘要——旧的没丢，只是压缩了。

会话间的记忆传递#

TARS 每次醒来不是同一个进程，而是一个全新的 LLM 会话。它之所以感觉有记忆，是因为上一次的 TARS 在退出前调了 save_session——写了日记摘要、更新了实体状态、标记了已解决的 pending。下一次的 TARS 读到这些，就像读到了自己上一次留下的笔记。

四、六层能力栈#

1
Evidence Capture   → 不可变记录。用户说了什么、做了什么、情绪如何
2
Behavior Understanding → 条件化 IF-THEN 规则。不是人格标签，是行为规律
3
Prediction & Learning    → 预测→现实打脸→校准→Meta Learning（曾被推翻的假设未来自动降权）
4
Self Model Evolution     → 月度快照 + 变化速率 + Plasticity（可塑性）
5
Interaction Policy       → Agent 根据对用户的理解调整自己的行为——deadline驱动的人自动拆小目标
6
Adaptive Response        → 不只是理解用户，是学会怎么跟用户协作

五、Intent Parser — 意图分类#

每条消息进入 TARS 时，LLM 先判断它属于什么行为类型，然后走对应通道。

核心边界：问题是关于外部世界的，还是关于用户自己的。

行为类型	例子	lifecycle	后续
emotional_release	“操他妈的""好焦虑”	fact	记情绪。check-in 时泛问恢复，不追问单条
commitment	“我要考雅思""明天学英语”	pending	创建承诺 + 预测成功率。check-in 追问
decision	“要不要读研”	pending	记决策点。季度回顾
self_reflection	“为什么我总拖延”	pending	记自我认知。触发 Self Model 更新
curiosity	“地球为什么是圆的”	fact	回答。不主动追问
meta_cognition	“为什么我总犹豫”	pending	提假设。check-in 跟进
idea_capture	“我突然想到一个产品”	fact	存 Idea 库。90天不提自动归档
data_log	“52kg""背了200单词”	fact	记时序数据。不追问
memory_recall	“我之前是不是说过”	fact	检索旧记忆
identity_question	“你觉得我是怎样的人”	fact	即时回答 Self Model
casual	“哈哈哈""好累""吃饭去了”	fact	只存。默认兜底通道

默认规则：拿不准 → casual → fact → 只存不追问。不丢数据。

六、运行时模型#

TARS 不常驻后台。macOS 快捷指令定时踹，Docker 容器按需启动。

1
你的 MacBook
2
  ├─ 7:00  快捷指令踹 → 生成内参 PDF → 发邮件
3
  ├─ 21:00 快捷指令踹 → 晚间 check-in → Telegram 追问
4
  └─ 随手踹 → 拉 Telegram 消息 → 有新消息进入即时通信 → 30分钟空闲退出

Telegram 场景：你在外面用手机发消息给 TARS bot → 消息在 Telegram 服务器排队 → 回家 MacBook 被踹 → TARS 拉回来处理。

8 个 CLI 命令，tars 封装所有 Docker 参数：

1
tars         日常踹一脚
2
tars setup   安装引导
3
tars talk    对话模式（rich 渲染 Markdown，方向键正常）
4
tars check   系统自检
5
tars pack    打包备份
6
tars migrate 生成完整迁移包（镜像+数据+配置一把带走）

七、技术架构#

组件	选型
LLM	Anthropic SDK + DeepSeek 兼容端点
数据库	SQLite + SQLAlchemy — 30 张表
向量	Chroma + BAAI/bge-small-zh-v1.5
Telegram	python-telegram-bot getUpdates
PDF 报告	Markdown + Jinja2 + WeasyPrint + Noto CJK
终端渲染	rich（Markdown 渲染）+ readline（方向键）
容器	Docker
调度	macOS 快捷指令 + task_dispatcher
版本控制	GitPython + git

代码规模：~6400 行 Python，83 个 MCP 工具，12 条定时任务。

八、定时任务 — Memory 自己生长#

1
凌晨 2:00  nightly  推理验证 + 假设审查 + 归档 + 衰减 + 冲突检测
2
凌晨 3:00  weekly   周模式 + 情绪趋势 + 压缩
3
凌晨 4:00  monthly  月特质 + 行为指标 + 交互策略更新 + Self Model 快照
4
凌晨 5:00  quarterly 季度行为统计 + worldview gap + Plasticity
5
早上 7:00  内参报告 PDF → 邮箱
6
晚上 21:00 check-in  注意力预算 + drift 追问 + 冲突提醒

补跑机制：MacBook 睡眠错过了凌晨任务 → 开机后第一次 tick 自动检测并补跑。不会静默跳过。

九、自我进化#

TARS 可以修改自己的代码。write_file、edit_file、register_task、run_command、git_revert 都在 MCP 工具里。

1
用户说"帮我每天十点提醒喝水"
2
  → TARS 写新工具文件到 layer1/tools/
3
  → 注册定时任务到 tasks.yaml
4
  → git commit
5
  → 下次 tick 自动加载生效
6
  → 改坏了就 git_revert 回滚

内核（layer0）也可修改——安全网是 git，不是权限墙。

十、安装#

Terminal window

1
cd ~/life-agent
2
bash scripts/bootstrap.sh
3
docker build -t life-agent .
4
bash scripts/install.sh
5
tars setup
6
tars talk

前置条件：Docker Desktop、Telegram + API、Telegram bot token。

【小白向】Mac设备音响排查记（扬声器不定时吱吱响破音

Fri, 21 Aug 2026 00:00:00 GMT

最近我的Macbook（M1 pro）不知道为什么，六扬声器在播放声音的时候会莫名有吱吱、噗噗的声音，关键的是响一下就没事了，还不能被手动复现，尤其在突然关闭正在播放声音的标签页、或者播放音量很高时，这种声音很恶心。起初我以为是我玩城市天际线，其内置的unity引擎音频流不兼容，玩的时候吱吱响把音响振膜搞坏了，但在进入安全模式后扬声器又正常了，气爆了，把驱动、Edge、后台进程都检查了个遍，最后发现是Todesk在安装时，也会装一个音频驱动运行在后台，与 macOS 的原生音频核心（Core Audio）存在兼容性问题，尤其是在音频流启动/停止的瞬间。以下是排查修复Mac设备扬声器的一个大概的流程，供各位参考思路，毕竟去线下店或者重装系统代价都不小：

1.重启，（若还有则直接下一步）
2.重启Mac按住 Shift 键直到登录界面，进入安全模式，如果安全模式下完全正常，即可 100% 确定是软件/驱动冲突，而非硬件损坏。（硬件损坏直接做好掏钱的准备吧）

3.终端执行sudo lsof | grep -i "coreaudio"查看音频驱动占用，寻找任何非苹果的驱动文件（.driver）。（在我的案例中，输出显示了 /Library/Audio/Plug-Ins/HAL/ToDeskOutputDriver.driver，这就是元凶）
4.检查系统扩展列表systemextensionsctl list,检查有无audio、virtual、loopback等第三方扩展。
5.在音频MIDI设置中，任何其他多余的虚拟设备都可能是冲突源

6.卸载相关软件，（比如我的Todesk）
7.在/Library/Audio/Plug-Ins/HAL/目录下，删除陌生的.driver文件
8.终端执行sudo killall coreaudiod
rm -rf ~/Library/Preferences/com.apple.audio.*
rm -rf ~/Library/Caches/com.apple.audio.*然后重启

Mac毕竟用户基数少，一般的软件bug修复周期就很缓慢，(比如城市天际线的音频兼容问题至今未修复)。如果还有问题，还是得跑线下啦

博客园同名 https://www.cnblogs.com/snyxz/

我和计算机

Mon, 06 Jul 2026 00:00:00 GMT

我建立本博客的目的只有一个，就是以维护博客为目的广泛的在计算机领域深耕。想想自己从第一次接触电脑开始，从自己第一次拆下电脑内存条到今天也有8年之久了，当时5年级的我，也是同样根据网上博客的教程一点一点的理解每一个硬件究竟是做什么用的，也算是第一次理解冯诺依曼体系。到我后来初一研究Linux，貌似起初是因为当初矿潮为了挖莱特币，专门装了Ubuntu优化性能，尽管现在看来的确没什么用，也受到当时Python引流课的影响，浅浅接触了编程领域。一旦男生接触到这方面的一个边边角角，一定会越陷越深。什么我的世界服务器、Kali CTF网安、vSphere虚拟化、甚至是路由器刷机，我几乎都尝了个遍，到后来初三开发网站给学校部署在线英语听力。不敢想当初到底有多沉迷于此（虽然有些嘉豪），记得中学时期当时有很多奇闻逸事，比如内网装宝塔面板，一路从Windows系统调试到路由器，就是不知道为啥连不通。很多当时看来的奇怪问题，现在想想都挺弱智，几乎我18岁以前的爱好都被这方面锁死了，直到后来顺其自然高考志愿报计算机，也算是业余转职业了，还有很多很多的有趣体验一时想不起来，可能未来某天在跟朋友聊天的时候会猛然想起，然后诉说当年的糗事。只恨几年来，没能养成写博客的习惯，所有这些宝贵的探索没能硬编码下来，但好在时间不晚，今天的我才大一，还有很多时间记录和进化。

我还要重申一遍本博客建立的主要目的是深耕计算机领域，至于竞争力或者未来就业的相关问题，我并没有考虑，我的动机很单纯。幻想一下，你现在30岁，回到家全屋智能家居已经接入你部署在刷完OpenWRT路由器的Home Assistance上，这个智能家居中枢联动了苹果生态Home Kit，几乎可以设置任何你想要的逻辑。同时在你的路由器上部署AdGuard和科学工具，再接入一个Agent Loop。配合你本地NAS上的N8N工作流，每周都会向你汇报家庭内的基本信息，气温、耗电量、博客浏览量和手机上网时间，小到个人体脂控制，大到家庭开支，总结成高效的PDF文档在你离开家后发送到你和家人的邮箱内。摄像头借助OpenCV计算机视觉搭配扫地机器人默默的在你回家之前完成全部家务，通风净化、洗衣烘干、设备自检，有条不紊，如果本地的Agent有需要，它会自动WOL启动我台式机完成重负载任务，一到周末，三五好友在你对智能音箱一声令下后打开全屋观影模式，投影布缓缓落下，随后Jellyfin查找你存在本地的蓝光杜比8K电影，Docker服务配合内网穿透把你远在天边的挚友拉进同一个MC服务器，你默默地站在人群中央，享受着Github开源带来的极致便利和簇拥，手持平板而掌管着这一切。这种淡淡的幸福感才是我等J人极致的追求，一直以来我都认为计算机科学是一门持续带来幸福的科学，想必皆归因于此。

以上是我个人的全部愿景，除此之外，别无二心！

这大概是我干过最逆天的事

Thu, 02 Jul 2026 00:00:00 GMT

如题，这条内容曾经拿到了上千浏览和几百点赞，今天重新写一遍，用现在的眼光回看23年。

原文发布于 QQ 空间，点击查看原文）

背景#

大概是高二，学校统一使用科大讯飞的所谓“AI辅助课堂教学“——每人发一台平板，深度定制 ROM。叫定制其实不算，说是阉割更准确：没浏览器，没原生系统设置，没文件管理器。相册只能看照片，视频播放器直接被砍了。本质上就是一台只能做题和交作业的电子砖头。

突破口#

我没事就翻预装软件，主页一个叫 GeoGebra 的东西很受学生追捧，官方说法是“数学动态画图工具”，数学好的考完试拿它研究最后一道大题，数学差的干脆直接用它当计算器，但我点进去就看出来了—这玩意儿是网页套壳的，很多时候这种非原生软件一眼就能看出来，同时用起来手感顿顿的大概率就是Electron、Tauri此类封装方案，但GeoGebra直接演都不演——纯WebView 套壳。

1
window.open("https://www.bing.com")

跳不出去。系统把 http/https 协议全封了CONNECTION_REFUSED，底层WebView 被魔改。而且输入框有过滤，输入直接吞字或者干扰。

柳暗花明#

第一处：键盘输入会被拦截，可以使用剪切板粘贴，从别处复制粘贴进来不走那条拦截逻辑，最后多输一个回车正好被吞掉，只剩下正确逻辑。

第二处：http不通，那就弃帅保车，使用file协议访问本地文件，好在我大概摸索出 Linux/Android 的目录结构了。

1
window.open("file:///storage/emulated/0/")

原生文件目录直接打开了，我欣喜若狂。能看到文件名、层级导航、文件大小。视频点进去，调用WebView就放了。

今日回首#

ifly的工程师大概是这么想的：把浏览器干掉、把 http/https 封掉、把输入拦截做好，学生就没办法了。

但他们漏了两件事：

WebView 本质上是浏览器。你可以不让它上网，但它读本地文件的权限是 Android 沙箱赋予的，不是 ROM 说了算的。
file 协议不需要网络权限，只读本地存储，你在 WebView 层面拦不住。

说穿了就是攻击面分析的问题：只封了网络层，没考虑本地文件系统层。

引爆#

我把方法整理成教程发到博客，顺手投稿到了表白墙，直接引爆——几百点赞，上千浏览，评论区全是”配享太庙”、“哥你是电教之神”之类，一时之间，风光无量。

开学第一周，级部广播直接点名diss：“我们级部还有个技术高手，掌握了比较高的计算机技术，破解出平板看视频的功能”。

随后发生的事，果不其然超出了我的控制范围，一开始可能只是传着看视频消遣，但后面有人用这个方法在家翻录电影、在宿舍熬夜追剧——一个数学画图工具被用成了娱乐终端。即便我在原博客郑重声明滥用的后果，失控的范围依旧远大于控制的成本，下架就成了唯一的选择。

没制裁我。但说实话，这件事我一直有点愧疚在心。

GeoGebra 是个好软件。数学课上用它画函数图像、做几何演示，确实比课本上的静态图直观太多。我用了快两年，很熟悉它的每一个角落——也正因如此，才看出它是网页套壳。讽刺的是，正因为我太了解它，才让它从全校平板上消失了，后面几届的学弟学妹连用都用不上了。技术上是我的一个高光时刻，但结果上，我带走的远比带来的多。

如果重来一次，我大概还是会发现那个漏洞——一个 WebView 套壳的应用放在一个对计算机充满好奇的高中生手里，这是迟早的事。但我可能不会把教程发到论坛上。

不过换个角度想，这件事之后我开始系统地研究前沿相关的技术，也学会了从”攻击面”的角度去审视一个系统的设计。某种意义上，它比我任何一门课给我的东西都多。

CC操作手册

Tue, 30 Jun 2026 00:00:00 GMT

一、Claude Code是如何工作的？#

Claude Code CLI可以直接api通信，如果是background任务则借助Daemon程序完成会话管理、agents池管理，定时任务等，Daemon开机自启后台活跃，终端内看到的是cli界面，bg任务控制权完全交给Daemon完成。

二、会话的管理#

claude code cli启动agent，默认kind是interactive branch后从当前节点复制出一份，分叉出独立会话 clear源对话归档，就地开启新对话 ba ckground后kind被标记为bg，控制权完全交由daemon exit正常结束，归档进project claude rm删的渣都不剩

三、存储结构#

一共四种记忆方式

history.jsonl 保存全局命令和用户prompt
projects/dir/id.jsonl 按项目隔离完整对话
projects/dir/memory/ 按项目隔离，自动注入新会话
安装目录CLAUDE.md 全局指令注入，项目级CLAUDE.md优先级更高

项目目录~/.claude/projects/ 内 -Users-wjh/ ← 你的项目之一 {id}.jsonl ← 每个会话的完整转录 memory/ ← 跨会话项目记忆（MEMORY.md + 各记忆文件）

根目录~/.claude/内 sessions/ ←当前活跃会话的元数据（pid、状态） session-env/ ← 每会话环境变量（残留，可清） shell-snapshots/ ← Shell 状态备份 file-history/ ← 文件修改前快照（用于 undo） backups/ ← settings.json 写前备份 plugins/ ← 已安装插件 settings.json ← 全局设置（主题、模型、权限） settings.local.json ← 本地覆盖（不参与同步） CLAUDE.md ← 全局指令（每次会话注入） history.jsonl ← 命令历史（↑ 键回溯） stats-cache.json ← 使用统计

四，Agent系统#

主对话（main agent）可派出子代理（sub-agent）最多派分出5层，子代理之间互不认识，只能通过接任务→交结果沟通一共有三级权限： Allow → 直接执行 Ask → 弹窗等你批准 Deny → 绝对不执行

五、对话内命令#

/init 扫描一遍项目目录，生成CLAUDE.md文件 /help General / Command / Custom Command三个界面显示不同的命令和快捷键的用法 /context 显示可视化不同上下文tokens占比，包括系统提示词、工具调用等 /config 总控面板，主题、权限、hook都在里面 /usage 显示token总用量和花费 /status 显示claude code版本、模型、目录和等基本信息 /recap 生成当前会话一句话摘要，走神回来快速回忆 /export 导出对话为纯文本，加文件名直接保存：/export 开发记录.txt /clear 归档原上下文，新开一个本项目空对话 /resume 恢复本项目已经归档的上下文文件 /compact 压缩上下文，在原来基础上压缩，context满时也会自动触发 /btw 单独开一个小对话，复制当前上下文到新session，之后完全独立，除非fork，无法调用工具 /copy 复制agent上一条输出 /diff 交互式 diff 查看器，检查未提交的代码改动，跟git协作使用 /insights 生成个人全局使用分析报告（HTML），含习惯分析、建议、未来工作流 /review 跟github协作，审查pr的效率质量，告诉你哪有毛病 /ultrareview 跟github协作，更狠地告诉你哪有毛病，更贵 /simplify 跟github协作，不废话，直接动手改 /plan 进入plan模式，只能看代码、搜索，不能改文件、不能运行非只读命令 /goal 进入goal模式，不再问要不要继续，不达目标誓不停止。中途/goal查看进度，/goal clear停止 /loop 举例：/loop 5m 检查一下部署状态，每5分钟daemon自动来一句发到对话里，/loop检查进度，/loop clear停止 /rewind 回退上文，注意只能在同一个对话文件内，包括三种 1. Restore conversation：对话和文件改动一起回到所选节点，节点之后的内容全部丢弃 2. Summarize from here：不改动文件，把所选节点之后的对话压缩成摘要，后面聊岔了但还想继续聊 3. Summarize up to here：不改动文件，把所选节点之前的对话压缩成摘要，前面太长，只想留最近清晰上下文 /branch 新建分支对话文件，注意不能用rewind，完全等于/fork /model 选择模型和思考力度（5档） /effort 只能调整思考力度 /fast 要求服务器加急处理推理，更贵 /mcp 管理mcp连接，接入外部服务 /plugin 插件市场，插件就是可以包含多个skill+主题+hooks的套件（hook是触发器，可以在agent工具调用前，会话启停时，停下来等等时设置跑命令，比如设置改文件前，先自动跑语法检查） /skills 管理接入的skill /rename 重命名当前对话 /background 把当前回话扔到后台，注意这是不可逆的，当前对话kind被标记为background，在claude agents中管理 /agents 显示当前会话内派出的子代理，涉及到复杂情景如并行搜索、独立出去干脏活累活时派出或者明确要用子代理去工作 /tasks 显示当前对话里正在跑的后台任务 /exit 关闭当前对话以及子代理

六、终端命令#

claude —bg “任务” 一步启动后台会话 claude —resume 直接恢复上次会话 claude —safe-mode 安全模式，禁用所有自定义项 claude agents 列出/管理所有后台会话 claude rm │ 删除指定会话 claude —print “任务” │ 非交互模式，输出结果到 stdout

[第2章 2.2e1] Palindromes

Sat, 27 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
bool solve(){
6
    string str;
7
    cin>>str;
8
    ll len=str.size();
9
    for(ll i=0;i<len;i++){
10
        if(str[i]!=str[len-i-1])return false;
11
    }
12
    return true;
13
}
14
int main(){
15
    ll t;
16
    cin>>t;
17
    while(t--){
18
        if(solve())cout<<"yes"<<endl;
19
        else cout<<"no"<<endl;
20
    }
21
    return 0;
22
}

展开收起

[第2章 2.2t1] Subsequence

Sat, 27 Jun 2026 00:00:00 GMT

1
2

[第1章 1.1e1] 约瑟夫问题

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意使用erase操作后赋值一定要判断迭代器合法性
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
void solve(){
6
    ll n,m;
7
    cin>>n>>m;
8
    list<ll> nd;
9
    ll nn;
10
    for(ll i=1;i<=n;i++)nd.push_back(i);
11
    ll st=nd.size();
12
    auto it=nd.begin();
13
    while(nd.size()>0){
14
        for(ll i=0;i<m-1;i++){
15
            it++;
16
            nn=*it;
17
            if(it==nd.end())it=nd.begin();
18
        }
19
        if(nd.size()!=st)cout<<" ";
20
        cout<<*it;
21
        it=nd.erase(it);
22
        if(it==nd.end())it=nd.begin();
23
    }
24
    cout<<endl;
25
}
26
int main(){
27
    solve();
28
    return 0;
29
}

展开收起

[第1章 1.1t1] 队列安排

Fri, 26 Jun 2026 00:00:00 GMT

1
//使用结构体数组模拟链表，节省查找时间，实在是高
2
//注意初始化中需要一个虚拟0位置作为全链条最左侧或最右侧
3
#include <bits/stdc++.h>
4
using namespace std;
5
typedef long long ll;
6
const ll MAXN=1e5+5;
7
struct node{
8
    ll l,r;
9
    ll d;
10
}m[MAXN];
11
void solve(){
12
    ll n;
13
    cin>>n;
14
    m[1].d=1;
15
    m[1].l=0,m[1].r=0;
16
    m[0].d=0;
17
    m[0].l=0,m[0].r=1;
18
    for(ll i=2;i<=n;i++){
19
        ll k,p;
20
        cin>>k>>p;
21
        if(p==0){
22
            m[i].r=k;
23
            m[i].l=m[k].l;
24
            m[m[k].l].r=i;
25
            m[k].l=i;
26
        }else{
27
            m[i].l=k;
28
            m[i].r=m[k].r;
29
            m[m[k].r].l=i;
30
            m[k].r=i;
31
        }
32
        m[i].d=1;
33
    }
34
    ll nn;
35
    cin>>nn;
36
    for(ll i=0;i<nn;i++){
37
        ll x;
38
        cin>>x;
39
        m[x].d=0;
40
    }
41
    ll now=m[0].r;
42
    while(now!=0){
43
        if(m[now].d){
44
            if(now!=m[0].r)cout<<" ";
45
            cout<<now;
46
        }
47
        now=m[now].r;
48
    }
49
    cout<<endl;
50
}
51
int main(){
52
    solve();
53
    return 0;
54
}

展开收起

[第1章 1.2e1] 机器翻译

Fri, 26 Jun 2026 00:00:00 GMT

1
//666小数据直接哈希加速，避免了遍历
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
queue<ll> qq;
6
vector<ll> hh(1010,0);
7
int main(){
8
    ll m,n;
9
    cin>>m>>n;
10
    ll cnt=0;
11
    for(ll i=0;i<n;i++){
12
        ll t;
13
        cin>>t;
14
        if(!hh[t]){
15
            hh[t]=1;
16
            qq.push(t);
17
            cnt++;
18
            while(qq.size()>m){
19
                hh[qq.front()]=0;
20
                qq.pop();
21
            }
22
        }
23
    }
24
    cout<<cnt<<endl;
25
    return 0;
26
}

展开收起

[第1章 1.2e2] 单调队列-滑动窗口

Fri, 26 Jun 2026 00:00:00 GMT

1
//666模拟了个优先队列，让这个队列头存当前最值
2
//但队列内存的是位置，便于比较和输出
3
//超出窗口后自动删掉前面多余部分
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
vector<ll> a;
8
int main(){
9
    ll n,k;
10
    cin>>n>>k;
11
    vector<ll> a(n);
12
    for(ll i=0;i<n;i++)cin>>a[i];
13
    deque<ll> lo;
14
    bool fla=false;
15
    for(ll i=0;i<n;i++){
16
        while(!lo.empty()&&a[lo.back()]>a[i])lo.pop_back();
17
        lo.push_back(i);
18
        if(i>=k-1){
19
            while(!lo.empty()&&i-lo.front()>=k)lo.pop_front();
20
            if(fla)cout<<" ";
21
            cout<<a[lo.front()];
22
            fla=true;
23
        }
24
    }
25
    cout<<endl;
26
    lo.clear();
27
    fla=false;
28
    for(ll i=0;i<n;i++){
29
        while(!lo.empty()&&a[lo.back()]<a[i])lo.pop_back();
30
        lo.push_back(i);
31
        if(i>=k-1){
32
            while(!lo.empty()&&i-lo.front()>=k)lo.pop_front();
33
            if(fla)cout<<" ";
34
            cout<<a[lo.front()];
35
            fla=true;
36
        }
37
    }
38
    cout<<endl;
39
    return 0;
40
}

展开收起

[第1章 1.2e3] Max Sum

Fri, 26 Jun 2026 00:00:00 GMT

1
//hdu1003最大字段和问题，以下为贪心解法，注意累计值大于历史最大值时更新左右边界
2
//也可以使用dp，先赋值为初始值，计算包括当前位置与之前的和，大于当前值则要前面的，否则左边界右移
3
//若大于历史最大值，更新边界，一定要注意区间不要带上产生最小值位置
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
void solve(ll ca){
8
    ll n;
9
    cin>>n;
10
    vector<ll>a(n+2);
11
    for(ll i=1;i<=n;i++)cin>>a[i];
12
    ll sum=0;
13
    ll l=1;
14
    ll a1=1,a2=1;
15
    ll ma=a[1];
16
    ll mi=0;
17
    for(ll r=1;r<=n;r++){
18
        sum+=a[r];
19
        ll cal=sum-mi;
20
        if(cal>ma){
21
            ma=cal;
22
            a1=l;
23
            a2=r;
24
        }
25
        if(sum<mi){
26
            mi=sum;
27
            l=r+1;
28
        }
29
    }
30
    cout<<"Case "<<ca<<":"<<endl;
31
    cout<<ma<<" "<<a1<<" "<<a2<<endl;
32
}
33
int main(){
34
    ll t;
35
    cin>>t;
36
    for(ll i=1;i<=t;i++){
37
        if(i!=1)cout<<endl;
38
        solve(i);
39
    }
40
    return 0;
41
}

展开收起

[第1章 1.2t1] 求m区间内的最小值

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意密集使用到endl，就需要像以下这样加速
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,m;
8
    cin>>n>>m;
9
    vector<ll> a(n+1);
10
    deque<ll> dq;
11
    cout<<0<<'\n';
12
    for(ll i=1;i<=n;i++)cin>>a[i];
13
    for(ll i=1;i<n;i++){
14
        while(!dq.empty()&&a[dq.back()]>a[i])dq.pop_back();
15
        dq.push_back(i);
16
        while(!dq.empty()&&i-dq.front()>=m)dq.pop_front();
17
        cout<<a[dq.front()]<<'\n';
18
    }
19
    return 0;
20
}

展开收起

[第1章 1.2t2] 扫描

Fri, 26 Jun 2026 00:00:00 GMT

1
//注意不要越界和while循环
2
#include <bits/stdc++.h>
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,k;
8
    cin>>n>>k;
9
    vector<ll> num(n+5);
10
    for(ll i=1;i<=n;i++)cin>>num[i];
11
    deque<ll> dq;
12
    for(ll i=1;i<=n;i++){
13
        while(!dq.empty()&&num[dq.back()]<num[i])dq.pop_back();
14
        dq.push_back(i);
15
        if(i>=k){
16
            while(!dq.empty()&&i-dq.front()>=k)dq.pop_front();
17
            cout<<num[dq.front()]<<'\n';
18
        }
19
    }
20
    return 0;
21
}

展开收起

[第1章 1.2t3] 切蛋糕

Fri, 26 Jun 2026 00:00:00 GMT

1
//没想到使用队列，建立一个sum累计数组，注意不要i==dq.front否则出现0污染结果
2
//每增加一个位置，要先检查大小，在运用窗口极小值算出最大值，同ans更新
3
//同时检测用当前值将dq更新成小于它的队列，保证单增，开始位置最小
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    ll n,m;
9
    cin>>n>>m;
10
    ll a;
11
    vector<ll> sum(n+3,0);
12
    for(ll i=1;i<=n;i++){
13
        cin>>a;
14
        sum[i]=sum[i-1]+a;
15
    }
16
    deque<ll> dq;
17
    ll ans=-1e18;
18
    dq.push_back(0);
19
    for(ll i=1;i<=n;i++){
20
        while(!dq.empty()&&i-dq.front()>m)dq.pop_front();
21
        ans=max(ans,sum[i]-sum[dq.front()]);
22
        while(!dq.empty()&&sum[dq.back()]>=sum[i])dq.pop_back();
23
        dq.push_back(i);
24
    }
25
    cout<<ans<<endl;
26
    return 0;
27
}

展开收起

[第1章 1.2t4] 好消息坏消息

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题深入理解了两项
2
//1.针对每个窗口要先清整，再推入，最后判断窗口大小
3
//2.使用sum数组可以解决此类涉及到求和的问题
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    ll n;
9
    cin>>n;
10
    vector<ll> a(2*n+2);
11
    for(ll i=1;i<=n;i++){
12
        cin>>a[i];
13
        a[n+i]=a[i];
14
    }
15
    vector<ll> sum(2*n+2);
16
    sum[0]=0;
17
    for(ll i=1;i<=2*n;i++){
18
        sum[i]=sum[i-1]+a[i];
19
    }
20
    deque<ll> dq;
21
    ll ans=0;
22
    for(ll i=1;i<2*n;i++){
23
        while(!dq.empty()&&sum[dq.back()]>=sum[i])dq.pop_back();
24
        dq.push_back(i);
25
        if(i>=n){
26
            while(!dq.empty()&&i-dq.front()>n)dq.pop_front();
27
            if(sum[dq.front()]-sum[i-n]>=0)ans++;
28
        }
29
    }
30
    cout<<ans<<endl;
31
    return 0;
32
}

展开收起

[第1章 1.2t5] 良好的感觉

Fri, 26 Jun 2026 00:00:00 GMT

1
//单调栈问题注意2个stack与a[n]哨兵
2
//前一个确保top可访问，并且初始位置可被计算
3
//第二个确保最后全部位置都被清算，这里设计的很棒
4
//注意要在本轮res计算完成后push
5
#include <bits/stdc++.h>
6
using namespace std;
7
typedef long long ll;
8
int main(){
9
    ll n;
10
    cin>>n;
11
    vector<ll> a(n+2,0),sum(n+2,0),res(n+2,0);
12
    for(ll i=1;i<=n;i++)cin>>a[i];
13
    n++;
14
    stack<ll> st;
15
    st.push(0);
16
    ll ans=0;
17
    for(ll i=1;i<=n;i++){
18
        sum[i]=sum[i-1]+a[i];
19
        while(!st.empty()&&a[st.top()]>a[i]){
20
            ll tp=st.top();
21
            st.pop();
22
            res[tp]+=(sum[i-1]-sum[tp]);
23
        }
24
        res[i]=(sum[i]-sum[st.top()]);
25
        st.push(i);
26
    }
27
    for(ll i=1;i<=n;i++){
28
        ans=max(ans,res[i]*a[i]);
29
    }
30
    cout<<ans<<endl;
31
    return 0;
32
}

展开收起

[第1章 1.2t6] 机器翻译-NOIP

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
using namespace std;
3
typedef long long ll;
4
queue<ll> qq;
5
vector<ll> hh(1010,0);
6
int main(){
7
    ll m,n;
8
    cin>>m>>n;
9
    ll cnt=0;
10
    for(ll i=0;i<n;i++){
11
        ll t;
12
        cin>>t;
13
        if(!hh[t]){
14
            hh[t]=1;
15
            qq.push(t);
16
            cnt++;
17
            while(qq.size()>m){
18
                hh[qq.front()]=0;
19
                qq.pop();
20
            }
21
        }
22
    }
23
    cout<<cnt<<endl;
24
    return 0;
25
}

展开收起

[第1章 1.2t7] 跳房子

Fri, 26 Jun 2026 00:00:00 GMT

1
//滑动窗口队列+二分+DP
2
//此处二分当模版记住得了
3
//此处j只有在等到满足left后才++，此处把一个区间掰成2步处理很不错，值得借鉴，同时这也是运用队列的原因
4
#include <bits/stdc++.h>
5
using namespace std;
6
typedef long long ll;
7
const ll INF=1e18;
8
ll n,d,k;
9
vector<ll> x,s;
10
bool check(ll t){
11
    vector<ll> gain(n+1,-INF);
12
    deque<ll> dq;
13
    gain[0]=0;
14
    ll j=0;
15
    ll left=max(1LL,d-t),right=d+t;
16
    for(ll i=1;i<=n;i++){
17
        while(j<i&&x[i]-x[j]>=left){
18
            if(gain[j]!=-INF){
19
                while(!dq.empty()&&gain[dq.back()]<gain[j])dq.pop_back();
20
                dq.push_back(j);
21
            }
22
            j++;
23
        }
24
        while(!dq.empty()&&x[i]-x[dq.front()]>right)dq.pop_front();
25
        if(!dq.empty())gain[i]=gain[dq.front()]+s[i];
26
        else gain[i]=-INF;
27
        if(gain[i]>=k)return true;
28
    }
29
    return false;
30
}
31
int main(){
32
    cin>>n>>d>>k;
33
    x.resize(n+1),s.resize(n+1);
34
    for(ll i=1;i<=n;i++)cin>>x[i]>>s[i];
35
    ll r=1e9,l=0;
36
    ll ans=-1;
37
    while(l<=r){
38
        ll mid=(r+l)/2;
39
        if(check(mid)){
40
            ans=mid;
41
            r=mid-1;
42
        }else{
43
            l=mid+1;
44
        }
45
    }
46
    cout<<ans<<endl;
47
    return 0;
48
}

展开收起

[第1章 1.2t8] 琪露诺

Fri, 26 Jun 2026 00:00:00 GMT

1
//跟上一题有异曲同工之妙，把区间掰成两段，先把满足l的入队并排序
2
//接着消除不满足r的元素，使用dp不断计算每个位置的最大收益
3
//最后注意并非每个位置都可退出游戏，需要在合法i位置取最大值
4
//注意窗口主要维护的是j，i只是比较对象
5
#include <bits/stdc++.h>
6
using namespace std;
7
typedef long long ll;
8
const ll INF=-1e18;
9
int main(){
10
    ll n,l,r;
11
    cin>>n>>l>>r;
12
    vector<ll> a(n+1);
13
    vector<ll> gain(n+1,INF);
14
    gain[0]=0;
15
    deque<ll> qq;
16
    for(ll i=0;i<=n;i++)cin>>a[i];
17
    ll j=0;
18
    ll ans=INF;
19
    for(ll i=1;i<=n;i++){
20
        while(i>=j+l){
21
            if(gain[j]!=INF){
22
                while(!qq.empty()&&gain[qq.back()]<gain[j])qq.pop_back();
23
                qq.push_back(j);
24
            }
25
            j++;
26
        }
27
        while(!qq.empty()&&i-qq.front()>r)qq.pop_front();
28
        if(!qq.empty()){
29
            gain[i]=gain[qq.front()]+a[i];
30
            if(i+r>n)ans=max(ans,gain[i]);
31
        }
32
    }
33
    cout<<ans<<endl;
34
    return 0;
35
}

展开收起

[第1章 1.2t9] 小组队列

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n,m;
8
    cin>>n>>m;
9
    vector<pair<ll,ll>> a(n);
10
    deque<ll> se;
11
    vector<deque<pair<ll,ll>>> num(300);
12
    for(ll i=0;i<n;i++){
13
        cin>>a[i].first;
14
        a[i].second=i;
15
    }
16
    ll t;
17
    cin>>t;
18
    for(ll i=0;i<t;i++){
19
        string str;
20
        cin>>str;
21
        if(str=="push"){
22
            ll nn;
23
            cin>>nn;
24
            ll na=a[nn].first;
25
      ll nb=a[nn].second;
26
            if(num[na].empty()){
27
                se.push_back(na);
28
            }
29
            num[na].push_back({na,nb});
30
        }else{
31
            ll fr=se.front();
32
            cout<<num[fr].front().second<<endl;
33
            if(num[fr].size()==1){
34
                se.pop_front();
35
            }
36
            num[fr].pop_front();
37
        }
38
    }
39
    return 0;
40
}

展开收起

[第1章 1.3e1] Text Reverse

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll t;
7
    cin>>t;
8
    cin.ignore();
9
    while(t--){
10
        string str;
11
        getline(cin,str);
12
        stack<char> st;
13
        string oo;
14
        for(ll i=0;i<=str.size();i++){
15
            if(str[i]==' '||i==str.size()){
16
                while(!st.empty()){
17
                    oo.push_back(st.top());
18
                    st.pop();
19
                }
20
                if(i==str.size())oo.push_back(' ');
21
            }else st.push(str[i]);
22
        }
23
        cout<<oo<<endl;
24
    }
25
    return 0;
26
}

展开收起

[第1章 1.3e2] Look Up S

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll t;
7
    cin>>t;
8
    vector<ll> h(t+2),ans(t+2);
9
    deque<ll> dq;
10
    dq.push_back(t+1);
11
    for(ll i=1;i<=t;i++)cin>>h[i];
12
    h[t+1]=1e18;
13
    for(ll i=t;i>=1;i--){
14
        while(h[i]>=h[dq.back()])dq.pop_back();
15
        if(dq.back()==t+1)ans[i]=0;
16
        else ans[i]=dq.back();
17
        dq.push_back(i);
18
    }
19
    for(ll i=1;i<=t;i++)cout<<ans[i]<<endl;
20
    return 0;
21
}

展开收起

[第1章 1.3t1] 单调栈-模板

Fri, 26 Jun 2026 00:00:00 GMT

1
//单调栈
2
#include <bits/stdc++.h>
3
#define endl '\n'
4
using namespace std;
5
typedef long long ll;
6
int main(){
7
    ll n;
8
    cin>>n;
9
    vector<ll> ans(n+2),a(n+2);
10
    deque<ll> dq;
11
    a[n+1]=1e18;
12
    dq.push_back(n+1);
13
    for(ll i=1;i<=n;i++)cin>>a[i];
14
    for(ll i=n;i>=1;i--){
15
        while(a[dq.back()]<=a[i])dq.pop_back();
16
        if(dq.back()==n+1)ans[i]=0;
17
        else ans[i]=dq.back();
18
        dq.push_back(i);
19
    }
20
    for(ll i=1;i<=n;i++){
21
        if(i!=1)cout<<" ";
22
        cout<<ans[i];
23
    }
24
    cout<<endl;
25
    return 0;
26
}

展开收起

[第1章 1.3t2] 后缀表达式

Fri, 26 Jun 2026 00:00:00 GMT

1
//直接用ac、bc作为临时数据，出现.完成一次计算
2
#include <bits/stdc++.h>
3
#define endl '\n'
4
using namespace std;
5
typedef long long ll;
6
int main(){
7
    string str;
8
    cin>>str;
9
    deque<ll> dq;
10
    ll ac=0,bc=0;
11
    ll a,b;
12
    for(ll i=0;i<str.size();i++){
13
        auto it=str[i];
14
            switch (it){
15
            case '@':
16
                break;
17
            case '.':
18
                dq.push_back(ac);
19
                ac=bc=0;
20
                break;
21
            case '+':
22
                a=dq.back();
23
                dq.pop_back();
24
                b=dq.back();
25
                dq.pop_back();
26
                dq.push_back(a+b);
27
                break;
28
            case '-':
29
                a=dq.back();
30
                dq.pop_back();
31
                b=dq.back();
32
                dq.pop_back();
33
                dq.push_back(b-a);
34
                break;
35
            case '*':
36
                a=dq.back();
37
                dq.pop_back();
38
                b=dq.back();
39
                dq.pop_back();
40
                dq.push_back(a*b);
41
                break;
42
            case '/':
43
                a=dq.back();
44
                dq.pop_back();
45
                b=dq.back();
46
                dq.pop_back();
47
                dq.push_back(b/a);
48
                break;
49
            default:
50
                ac=bc*10+it-'0';
51
                bc=ac;
52
                break;
53
        }
54
    }
55
    cout<<dq.back()<<endl;
56
    return 0;
57
}

展开收起

[第1章 1.3t3] 表达式括号匹配

Fri, 26 Jun 2026 00:00:00 GMT

1
//小心))((
2
//一定要确保操作数据结构时，是非空状态，否则RE
3
#include <bits/stdc++.h>
4
#define endl '\n'
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    string str;
9
    cin>>str;
10
    stack<char> st;
11
    for(ll i=0;i<str.size();i++){
12
        if(str[i]=='(')st.push('(');
13
        else if(str[i]==')'){
14
            if(st.empty()){
15
                cout<<"NO"<<endl;
16
                return 0;
17
            }
18
            st.pop();
19
        }
20
    }
21
    if(!st.empty())cout<<"NO"<<endl;
22
    else cout<<"YES"<<endl;
23
    return 0;
24
}

展开收起

[第1章 1.3t4] 表达式求值

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    string str;
7
    cin>>str;
8
    ll a=0,b=0;
9
    str.push_back(1);
10
    stack<ll> st;
11
    ll acc=1;
12
    ll ans=0;
13
    for(ll i=0;i<=str.size();i++){
14
        auto it=str[i];
15
        ans%=10000;
16
        acc%=10000;
17
        a%=10000;
18
        b%=10000;
19
        if(it=='+'||i==str.size()-1){
20
            ans+=(acc*a);
21
            acc=1;
22
            a=b=0;
23
            if(i==str.size())break;
24
        }else if(it=='*'){
25
            acc*=a;
26
            a=b=0;
27
        }else{
28
            a=b*10+it-'0';
29
            b=a;
30
        }
31
    }
32
    cout<<ans<<endl;
33
    return 0;
34
}

展开收起

[第1章 1.3t5] 表达式的转换

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
ll power(char a){
6
    if(a=='+'||a=='-')return 1;
7
    if(a=='*'||a=='/')return 2;
8
    if(a=='^')return 3;
9
    return 0;
10
}
11
bool isop(string it){
12
    if(it.size()==1&&string{"+-*/^"}.find(it[0])!=string::npos)return true;
13
    return false;
14
}
15
ll kua(ll a,ll b){
16
    ll ans=1;
17
    while(b){
18
        if(b%2)ans*=a;
19
        b/=2;
20
        a*=a;
21
    }
22
    return ans;
23
}
24
ll ca(ll a,ll b,char c){
25
    if(c=='+')return b+a;
26
    if(c=='-')return b-a;
27
    if(c=='*')return b*a;
28
    if(c=='/')return b/a;
29
    if(c=='^')return kua(b,a);
30
}
31
int main(){
32
    string str;
33
    cin>>str;
34
    vector<string> dq;
35
    deque<char> cal;
36
    for(ll i=0;i<str.size();){
37
        char cnt=str[i];
38
        if('0'<=cnt&&cnt<='9'){
39
            string num;
40
            while(i<str.size()&&('0'<=str[i]&&str[i]<='9'))
41
                num+=str[i++];
42
            dq.push_back(num);
43
            continue;
44
        }else if(cnt=='('){
45
            cal.push_back('(');
46
        }else if(cnt==')'){
47
            while(!cal.empty()&&cal.back()!='('){
48
                string tran=string(1,cal.back());
49
                dq.push_back(tran);
50
                cal.pop_back();
51
            }
52
            if(!cal.empty())cal.pop_back();
53
        }else{
54
            while(!cal.empty()&&cal.back()!='('){
55
                if(power(cnt)<=power(cal.back())&&cnt!='^'){
56
                    dq.push_back(string(1,cal.back()));
57
                    cal.pop_back();
58
                }else break;
59
            }
60
            cal.push_back(cnt);
61
        }
62
        i++;
63
    }
64
    while(!cal.empty()){
65
        dq.push_back(string(1,cal.back()));
66
        cal.pop_back();
67
    }
68
    for(ll i=0;i<dq.size();i++){
69
        if(i!=0)cout<<' ';
70
        cout<<dq[i];
71
    }
72
    cout<<endl;
73
    while(dq.size()>1){
74
        for(ll j=0;j<dq.size();j++){
75
            if(isop(dq[j])){
76
                ll a=stoll(dq[j-1]);
77
                ll b=stoll(dq[j-2]);
78
                ll op=dq[j][0];
79
                dq.erase(dq.begin()+j-2,dq.begin()+j+1);
80
                dq.insert(dq.begin()+j-2,to_string(ca(a,b,op)));
81
                break;
82
            }
83
        }
84
        for(ll j=0;j<dq.size();j++){
85
            if(j!=0)cout<<' ';
86
            cout<<dq[j];
87
        }
88
        cout<<endl;
89
    }
90
    return 0;
91
}

展开收起

[第1章 1.4e1] Entropy-熵

Fri, 26 Jun 2026 00:00:00 GMT

1
//能按照树构建的顺序计算出ans的确没想到
2
//string类不存在访问到边界以外的位置导致内存错误
3
#include <bits/stdc++.h>
4
#define endl '\n'
5
using namespace std;
6
typedef long long ll;
7
int main(){
8
    string str;
9
    while(getline(cin,str)&&str!="END"){
10
        sort(str.begin(),str.end());
11
        priority_queue<ll,vector<ll>,greater<ll>> pq;
12
        ll num=1;
13
        for(ll i=1;i<=str.size();i++){
14
            if(str[i]!=str[i-1]){
15
                pq.push(num);
16
                num=1;
17
            }else num++;
18
        }
19
        ll ans=0;
20
        if(pq.size()==1)ans=str.size();
21
        while(pq.size()>1){
22
            ll a=pq.top();
23
            pq.pop();
24
            ll b=pq.top();
25
            pq.pop();
26
            ans+=a+b;
27
            pq.push(a+b);
28
        }
29
        printf("%lld %lld %.1lf\n",str.size()*8,ans,double(str.size())*8/ans);
30
    }
31
    return 0;
32
}

展开收起

[第1章 1.4t1] Safe Or Unsafe

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
bool solve(){
6
    ll n;
7
    cin>>n;
8
    string str;
9
    cin>>str;
10
    sort(str.begin(),str.end());
11
    priority_queue<ll,vector<ll>,greater<>> pq;
12
    ll num=1;
13
    for(ll i=1;i<=str.size();i++){
14
        if(str[i-1]!=str[i]){
15
            pq.push(num);
16
            num=1;
17
        }else num++;
18
    }
19
    ll ans=1;
20
    if(pq.size()==1)ans=str.size();
21
    while(pq.size()>1){
22
        ll a=pq.top();pq.pop();
23
        ll b=pq.top();pq.pop();
24
        ans+=a+b;
25
        pq.push(a+b);
26
    }
27
    if(ans<=n)return true;
28
    else return false;
29
}
30
int main(){
31
    ll t;
32
    cin>>t;
33
    while(t--){
34
        if(solve())cout<<"yes"<<endl;
35
        else cout<<"no"<<endl;
36
    }
37
    return 0;
38
}

展开收起

[第1章 1.4t2] FBI树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
ll len;
6
string ans;
7
vector<ll> num;
8
ll kuai(ll a,ll b){
9
    ll ans=1;
10
    while(b){
11
        if(b%2)ans*=a;
12
        b/=2;
13
        a*=a;
14
    }
15
    return ans;
16
}
17
char cal(ll l,ll r){
18
    if(r==l){
19
        if(num[l])return 'I';
20
        else return 'B';
21
    }
22
    ll mid=(l+r)/2;
23
    char lres=cal(l,mid);
24
    ans.push_back(lres);
25
    char rres=cal(mid+1,r);
26
    ans.push_back(rres);
27
    if(lres==rres&&lres=='I')return 'I';
28
    else if(lres==rres&&lres=='B')return 'B';
29
    else return 'F';
30
}
31
int main(){
32
    ll n;
33
    cin>>n;
34
    len=kuai(2,n);
35
    num.resize(len+1);
36
    for(ll i=1;i<=len;i++){
37
        char c;
38
        cin>>c;
39
        num[i]=c-'0';
40
    }
41
    ans.push_back(cal(1,len));
42
    cout<<ans<<endl;
43
    return 0;
44
}

展开收起

[第1章 1.4t3] 求先序排列

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
void fid(string fr,string be){
6
    if(fr.size()>0){
7
        char root=be.back();
8
        cout<<root;
9
        ll gap=fr.find(root),siz=fr.size();
10
        fid(fr.substr(0,gap),be.substr(0,gap));
11
        fid(fr.substr(gap+1,siz-gap),be.substr(gap,siz-gap-1));
12
    }
13
}
14
int main(){
15
    string fr,be;
16
    cin>>fr>>be;
17
    fid(fr,be);
18
    cout<<endl;
19
    return 0;
20
}

展开收起

[第1章 1.4t4] 新二叉树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<char,char> pll;
6
unordered_map<char,pll> mp;
7
void fid(char pos){
8
    char l=mp[pos].first,r=mp[pos].second;
9
    cout<<pos;
10
    if(l!='*')fid(l);
11
    if(r!='*')fid(r);
12
}
13
int main(){
14
    ios::sync_with_stdio(false);cin.tie(0);
15
    ll n;
16
    cin>>n;
17
    char root;
18
    for(ll i=0;i<n;i++){
19
        char a,b,c;
20
        cin>>a>>b>>c;
21
        if(i==0)root=a;
22
        mp[a]={b,c};
23
    }
24
    fid(root);
25
    cout<<endl;
26
    return 0;
27
}

展开收起

[第1章 1.4t5] 遍历问题

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题可以辅助理解前中后序遍历，前后遍历强调了根的位置，中序遍历强调了子树位置
2
//仅有前后遍历，无法构造确定的树，比如前序AB，后序BA，根都是A但B无法确定在哪个树上
3
//故如果要找树可能的形态就要找形如以上形式的个数，这是造成差异的原因
4
#include <bits/stdc++.h>
5
#define endl '\n'
6
using namespace std;
7
typedef long long ll;
8
int main(){
9
    string s1,s2;
10
    cin>>s1>>s2;
11
    ll ans=0;
12
    for(ll i=0;i<s1.size();i++){
13
        for(ll j=0;j<s2.size();j++){
14
            if(s1[i]==s2[j+1]&&s1[i+1]==s2[j])ans++;
15
        }
16
    }
17
    cout<<(ll)pow(2,ans)<<endl;
18
    return 0;
19
}

展开收起

[第1章 1.4t6] 对称二叉树

Fri, 26 Jun 2026 00:00:00 GMT

1
#include<bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<ll,ll> pll;
6
vector<ll> v;
7
vector<ll> tree;
8
unordered_map<ll,pll> mp;
9
ll count(ll x){
10
    if(x==-1)return 0;
11
    ll l=mp[x].first;
12
    ll r=mp[x].second;
13
    tree[x]=count(l)+count(r)+1;
14
    return tree[x];
15
}
16
bool mirror(ll x,ll y){
17
    if(x==-1&&y==-1)return true;
18
    if(x==-1||y==-1)return false;
19
    if(v[x]!=v[y])return false;
20
    return mirror(mp[x].first,mp[y].second)&&mirror(mp[x].second,mp[y].first);
21
}
22
int main(){
23
    ios::sync_with_stdio(false);cin.tie(0);
24
    ll n;
25
    cin>>n;
26
    tree.resize(n+1);
27
    v.resize(n+1);
28
    for(ll i=1;i<=n;i++)cin>>v[i];
29
    for(ll i=1;i<=n;i++){
30
        cin>>mp[i].first>>mp[i].second;
31
    }
32
    ll ans=0;
33
    count(1);
34
    for(ll i=1;i<=n;i++){
35
        if(mirror(i,i))ans=max(ans,tree[i]);
36
    }
37
    cout<<ans<<endl;
38
    return 0;
39
}

展开收起

[第1章 1.4t8] 荷马史诗

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
typedef pair<ll,ll> pll;
6
int main(){
7
    ll n,k;
8
    cin>>n>>k;
9
    priority_queue<pll,vector<pll>,greater<>> pq;
10
    for(ll i=1;i<=n;i++){
11
        ll w;
12
        cin>>w;
13
        pq.push({w,0});
14
    }
15
    ll ans=0;
16
    ll ma=0;
17
    while((pq.size()-1)%(k-1)!=0)pq.push({0,0});
18
    while(pq.size()>1){
19
        ll tmp=0;
20
        ll h=0;
21
        for(ll i=0;i<k;i++){
22
            tmp+=pq.top().first;
23
            h=max(h,pq.top().second);
24
            pq.pop();
25
        }
26
        ans+=tmp;
27
        pq.push({tmp,h+1});
28
    }
29
    cout<<ans<<endl<<pq.top().second<<endl;
30
    return 0;
31
}

展开收起

[第1章 1.5e1] 堆-模板

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n;
7
    cin>>n;
8
    priority_queue<ll,vector<ll>,greater<>>pq;
9
    while(n--){
10
        ll op;
11
        cin>>op;
12
        if(op==1){
13
            ll x;
14
            cin>>x;
15
            pq.push(x);
16
        }else if(op==2)cout<<pq.top()<<endl;
17
        else pq.pop();
18
    }
19
    return 0;
20
}

展开收起

[第1章 1.5t1] 合并果子

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ios::sync_with_stdio(false);cin.tie(0);
7
    ll n;
8
    cin>>n;
9
    priority_queue<ll,vector<ll>,greater<>> a;
10
    for(ll i=0;i<n;i++){
11
        ll tmp;
12
        cin>>tmp;
13
        a.push(tmp);
14
    }
15
    ll ans=0;
16
    while(a.size()>1){
17
        ll aa=a.top();a.pop();
18
        ll bb=a.top();a.pop();
19
        ans+=aa+bb;
20
        a.push(aa+bb);
21
    }
22
    cout<<ans<<endl;
23
    return 0;
24
}

展开收起

[第1章 1.5t2] 中位数

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n;
7
    cin>>n;
8
    priority_queue<ll> r;
9
    priority_queue<ll,vector<ll>,greater<>> l;
10
    ll tmp;
11
    cin>>tmp;
12
    cout<<tmp<<endl;
13
    r.push(tmp);
14
    for(ll i=1;i<n;i++){
15
        cin>>tmp;
16
        if(tmp>r.top())l.push(tmp);
17
        else r.push(tmp);
18
        while(r.size()>l.size()+1){
19
            l.push(r.top());r.pop();
20
        }
21
        while(l.size()>r.size()+1){
22
            r.push(l.top());l.pop();
23
        }
24
        if(i%2==0)cout<<(l.size()>r.size()?l.top():r.top())<<endl;
25
    }
26
    return 0;
27
}

展开收起

[第1章 1.5t3] 最小函数值

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5

6
struct node {
7
    ll w;
8
    ll a, b, c;
9
    ll cntx = 1;
10
};
11

12
struct cmp {
13
    bool operator()(const node &a, const node &b) const {
14
        return a.w > b.w;
15
    }
16
};
17

18
int main() {
19
    ll n, m;
20
    cin >> n >> m;
21
    priority_queue<node, vector<node>, cmp> pq;
22
    for (ll i = 0; i < n; i++) {
23
        ll a, b, c;
24
        cin >> a >> b >> c;
25
        node po;
26
        po.a = a, po.b = b, po.c = c;
27
        po.cntx = 1;
28
        po.w = a + b + c;
29
        pq.push(po);
30
    }
31
    while (m--) {
32
        auto f = pq.top();
33
        pq.pop();
34
        cout << f.w << " ";
35
        f.cntx++;
36
        f.w = f.a * f.cntx * f.cntx + f.b * f.cntx + f.c;
37
        pq.push(f);
38
    }
39
    cout<<endl;
40
    return 0;
41
}

展开收起

[第1章 1.5t4] 蚯蚓

Fri, 26 Jun 2026 00:00:00 GMT

1
#include <bits/stdc++.h>
2
#define endl '\n'
3
using namespace std;
4
typedef long long ll;
5
int main(){
6
    ll n,m,q,u,v,t;
7
    cin>>n>>m>>q>>u>>v>>t;
8
    deque<ll> q1,q2,q3;
9
    for(ll i=0;i<n;i++){
10
        ll tmp;
11
        cin>>tmp;
12
        q1.push_back(tmp);
13
    }
14
    bool bk=false;
15
    sort(q1.begin(),q1.end(),greater<ll>());
16
    for(ll i=0;i<m;i++){
17
        ll ma=LLONG_MIN,lo=0;
18
        if(!q1.empty()&&q1.front()>ma)ma=q1.front(),lo=1;
19
        if(!q2.empty()&&q2.front()>ma)ma=q2.front(),lo=2;
20
        if(!q3.empty()&&q3.front()>ma)ma=q3.front(),lo=3;
21
        if(lo==1)q1.pop_front();
22
        else if(lo==2)q2.pop_front();
23
        else q3.pop_front();
24
        ma+=i*q;
25
        ll res1=ma*u/v,res2=ma-res1;
26
        q2.push_back(res1-q-i*q);
27
        q3.push_back(res2-q-i*q);
28
        if((i+1)%t==0){
29
            if(bk)cout<<' ';
30
            cout<<ma;
31
            bk=false;
32
        }
33
    }
34
    bk=true;
35
    cout<<endl;
36
    for(ll i=0;i<n+m;i++){
37
        ll ma=LLONG_MIN,lo=0;
38
        if(!q1.empty()&&q1.front()>ma)ma=q1.front(),lo=1;
39
        if(!q2.empty()&&q2.front()>ma)ma=q2.front(),lo=2;
40
        if(!q3.empty()&&q3.front()>ma)ma=q3.front(),lo=3;
41
        if(lo==1)q1.pop_front();
42
        else if(lo==2)q2.pop_front();
43
        else q3.pop_front();
44
        if((i+1)%t==0){
45
            if(bk)cout<<' ';
46
            cout<<ma;
47
            bk=false;
48
        }
49
    }
50
    cout<<endl;
51
    return 0;
52
}

展开收起

[第1章 1.5t5] Cow Coupons G

Fri, 26 Jun 2026 00:00:00 GMT

1
//本题为反悔贪心，总结一下堆的知识，着重在于考察利用某些性质管理不同堆解决问题
2
//反悔贪心在于每次都比较一下是硬着头皮上还是选择反悔一次代价最小的
3
//如果是后者回报高，那就付出代价，把仅有的减免机会让给c组
4
//注意使用buy数组同步p和c组内已买过的物品，每一轮都要删掉已买的，保证一致性
5
#include <bits/stdc++.h>
6
#define endl '\n'
7
using namespace std;
8
typedef long long ll;
9
typedef struct{
10
    ll pri,pre;
11
    ll ord;
12
}pll;
13
struct cmp1{
14
    bool operator()(const pll &a,const pll &b){
15
        return a.pri>b.pri;
16
    }
17
};
18
struct cmp2{
19
    bool operator()(const pll &a,const pll &b){
20
        return a.pre>b.pre;
21
    }
22
};
23
int main(){
24
    ll n,k,m;
25
    cin>>n>>k>>m;
26
    vector<bool> buy(n,false);
27
    priority_queue<pll,deque<pll>,cmp1>p;
28
    priority_queue<pll,deque<pll>,cmp2>c;
29
    priority_queue<ll,deque<ll>,greater<>>delta;
30
    for(ll i=0;i<k;i++)delta.push(0);
31
    for(ll i=0;i<n;i++){
32
        pll tmp;
33
        cin>>tmp.pri>>tmp.pre;
34
        tmp.ord=i;
35
        p.push(tmp);
36
        c.push(tmp);
37
    }
38
    ll ans=0;
39
    while(!p.empty()){
40
        while(!p.empty()&&buy[p.top().ord])p.pop();
41
        while(!c.empty()&&buy[c.top().ord])c.pop();
42
        if(p.empty())break;
43
        if(p.top().pri<=c.top().pre+delta.top()){
44
            m-=p.top().pri;
45
            if(m<0)break;
46
            buy[p.top().ord]=true;
47
            ans++;
48
        }else{
49
            m-=delta.top()+c.top().pre;
50
            if(m<0)break;
51
            buy[c.top().ord]=true;
52
            delta.pop();
53
            delta.push(c.top().pri-c.top().pre);
54
            ans++;
55
        }
56
    }
57
    cout<<ans<<endl;
58
    return 0;
59
}

展开收起

hecloud.top

00 概述

卷一#

卷二#

第 1 章 Java 程序设计概述

1.1 Java 程序设计平台#

1.2 Java 白皮书的关键术语#

1.3 Java applet 与 Internet#

1.4 Java 发展简史#

1.5 关于 Java 的常见误解#

第 2 章 Java 编程环境#

相关名词解释#

以下可以等用到再了解#

2.1 安装 Java 开发工具包#

2.2 使用命令行工具#

2.3 使用集成开发环境#

2.4 JShell#

第 3 章 Java 的基本程序设计结构#

3.1 一个简单的 Java 程序#

3.2 注释#

3.3 数据类型#

3.4 变量与常量#

3.5 运算符#

3.6 字符串#

3.7 输入与输出#

3.8 控制流程#

3.9 大数#

3.10 数组#

附录#

日期#

小结：Java vs C 对照表#

蜂窝版 MacBook：80 块钱让 Mac 直插 4G 卡上网 + 保号接码

写在前面：这不是「破解」，是「切换」#

为什么是这颗模块#

我要实现的两个目标#

材料清单#

第一步：让 Mac 能上网（改 ID + 切 ECM）#

第二步：部署 VoHive（保号/接码）#

踩坑记录（这才是真干货）#

最终成果#

结语#

通信技术基础：先把这些名词搞懂#

一、什么是 LTE#

二、频段（Band）和频率的关系#

三、信道（Channel）#

四、FDD 与 TDD：中国和外国的「通信模式」#

五、三张身份证：IMEI / ICCID / IMSI#

六、模块的四种「工作模式」#

七、两种「管理模式」：AT 和 QMI——你怎么指挥这颗芯片#

八、APN 是什么#

九、USSD 是什么#

十、DTMF 通信是什么#

十一、VoWiFi 是什么#

Markdown 入门教程：一篇就够了

1. 标题语法#

一级标题#

二级标题#

三级标题#

2. 文字强调#

3. 列表结构#

无序列表（使用 - 或 *）#

有序列表（使用数字加点）#

4. 链接与图片#

5. 代码块#

TARS — 个人 AI 管家

这个项目暂时废了，后期准备包装成obsidina插件发布，文档方式交互。#

一、为什么做 TARS#

二、什么是立场#

三、记忆系统#

三种存储，各司其职#

每次 tick 的装填过程#

记忆生命周期#

会话间的记忆传递#

四、六层能力栈#

五、Intent Parser — 意图分类#

六、运行时模型#

七、技术架构#

八、定时任务 — Memory 自己生长#

九、自我进化#

十、安装#