Hello.java  --javac 编译-->  Hello.class (字节码)  --JVM 解释/JIT-->  机器码执行

0: iconst_1     ← 把常量 1 压入操作数栈
1: istore_1     ← 弹出存到局部变量 1
2: iconst_2     ← 压入常量 2
3: istore_2     ← 存到局部变量 2
4: iload_1      ← 取局部变量 1
5: iload_2      ← 取局部变量 2
6: iadd         ← 相加
7: istore_3     ← 结果存变量 3

cd javase-demo

# ① 编译：src 目录所有 .java → out 目录的 .class
javac -encoding UTF-8 -d out src/*.java

# ② 运行：把 out 加入类路径（classpath），启动 Hello 类
java -Dfile.encoding=UTF-8 -cp out Hello

# ③ 反汇编：看字节码
javap -c -cp out Hello

# ④ 带依赖运行（第 15 章讲的外部库）
java -Dfile.encoding=UTF-8 -cp "out:lib/*" Demo5_Libs

1 + 2 = 3

Hello.java
   │ javac 编译（编译期：检查语法、类型）
   ▼
Hello.class（字节码）
   │ JVM 加载（类加载器：把 .class 读进内存）
   ▼
Hello 类（方法区元数据 + 堆中对象）
   │ JVM 解释执行 main 方法（运行期）
   ▼
程序输出

byte=127, short=32767, int=2147483647, long=9223372036854775807
float=3.14, double=3.141592653589793, char=中, boolean=true
注意: int 最大约 21 亿 —— 时间戳、ID 都要用 long!

int a = 100;              // 十进制
int b = 0b110_0100;       // 二进制（0b 前缀，下划线可用于易读分隔）
int c = 0100;             // 八进制（0 前缀）—— 慎用，容易看错！
int d = 0x64;             // 十六进制（0x 前缀）—— 调试内存/颜色常用
long e = 100L;            // long 后缀 L（小写 l 易看成 1，用大写）
float f = 3.14F;          // float 后缀 f
double g = 3.14;          // 小数默认 double
double h = 1e3;           // 科学计数法 = 1000.0
char i = 'A';             // 字符：单引号，只能一个字符
char j = '\n';            // 转义：\n 换行 \t 制表 \\ 反斜杠 \' \" 
char k = '\u4e2d';        // Unicode：\u 前缀 + 四位十六进制（'中'）
String s = "hello";       // 字符串：双引号（引用类型！）
String empty = null;      // 空引用（后面第 8 章讲 NullPointerException）

// ① 自动（小 → 大，安全）：byte → short → int → long → float → double
int a = 100;
long b = a;          // OK
double c = a;        // OK

// ② 强制（大 → 小，可能丢数据，必须写 (类型)）
double x = 3.99;
int y = (int) x;     // 3 —— 直接"砍掉"小数，不是四舍五入！

// ③ 运算中的隐式提升
int m = 5, n = 2;
double r = m / n;            // 2.0 —— 整数除法先算完再赋值！经典坑
double r2 = m / (double) n;  // 2.5 —— 把任意一方转成 double 才对

// ④ char ↔ int
char ch = 'A';
int code = ch;       // 65
char next = (char) (code + 1);  // 'B'

var name = "Java";                    // 推断为 String
var list = new ArrayList<String>();   // 推断为 ArrayList<String>
var map = new HashMap<String, Integer>();
var count = 10;                       // 推断为 int

var name -> String : Java
var list -> ArrayList [a]
var map  -> HashMap {one=1}
限制：只能用于局部变量 + 必须有初始值 + 不能接 null（编译器会拦）

int a = 7, b = 2;
System.out.println(a + b);   // 9
System.out.println(a - b);   // 5
System.out.println(a * b);   // 14
System.out.println(a / b);   // 3  —— 整数除法，砍掉小数！
System.out.println(a % b);   // 1  —— 取模（余数）
System.out.println(a / 2.0); // 3.5 —— 有小数参与才是精确的

int i = 1;
i++;       // i = 2（先用后加）
++i;       // i = 3（先加后用）
i += 5;    // i = 8（复合赋值：+= -= *= /= %=）

int x = 0b1100;   // 12
int y = 0b1010;   // 10
x & y    // 0b1000 = 8   与：都为 1 才为 1
x | y    // 0b1110 = 14  或：有 1 就为 1
x ^ y    // 0b0110 = 6   异或：不同为 1（可用来"翻转/找不同"）
~x       // 取反
x << 1   // 24  左移 1 位 = 乘 2（低位补 0）
x >> 1   // 6   右移 1 位 = 除以 2（保留符号）
x >>> 1  // 无符号右移（高位补 0）

int max = a > b ? a : b;                    // 取较大值
String tag = score >= 60 ? "及格" : "不及格"; // 嵌入判断

// ① if / else if / else —— 最常用
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("补考");
}

// 形态一：经典 switch（有"穿透"风险，必须写 break）
switch (day) {
    case 1:
        System.out.println("周一");
        break;          // 忘了 break 会"穿透"执行下一个 case —— 经典 bug
    default:
        System.out.println("其他");
}

// 形态二：switch 表达式 + 箭头（JDK14+）—— 无穿透、能返回值
String type = switch (day) {
    case 1, 2, 3, 4, 5 -> "工作日";
    case 6, 7 -> "休息日";
    default -> "非法日期";
};

// 形态三：分支里要写多行逻辑时，用代码块 + yield 返回值
String type2 = switch (day) {
    case 1, 2, 3, 4, 5 -> "工作日";
    case 6, 7 -> "休息日";
    default -> {
        int n = day - 7;
        yield "非法(超出 " + n + " 天)";   // yield = "这个分支的返回值"
    }
};

day = 3 → 工作日   ← 还能作为表达式直接赋值

  day=1 → 工作日
  day=6 → 休息日
  day=7 → 休息日
  day=9 → 非法(编号=4)
特点：能返回值、无 fall-through 穿透、必须穷尽

// ① for：次数明确
for (int i = 0; i < 5; i++) { ... }

// ② 增强 for（for-each）：遍历数组/集合，只读最舒服
int[] arr = {5, 8, 9};
for (int v : arr) { System.out.print(v + " "); }   // 5 8 9

// ③ while：条件驱动
while (queueNotEmpty()) { ... }

// ④ do-while：至少执行一次（先做后判）
do { ... } while (retry());

for (...) {
    if (skip)  continue;   // 跳过本次循环，进下一次
    if (done)  break;      // 结束整个循环
}

// 带标签的循环（嵌套循环中"跳到外层"），面试偶尔考：
outer:
for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        if (i * j > 2) break outer;   // 直接跳出两层
    }
}

int[] a = new int[5];             // 声明 + 分配（元素默认 0）
int[] b = {1, 2, 3};              // 字面量初始化
int[] c = new int[]{1, 2, 3};     // 完整写法

int[] arr = {5, 2, 8, 1, 9};

System.out.println(arr.length);          // 5
System.out.println(arr[0]);              // 5（下标从 0 开始！）

// 遍历
for (int v : arr) System.out.print(v + " ");

// 复制（三选一）
int[] copy1 = arr.clone();
int[] copy2 = Arrays.copyOf(arr, arr.length);
int[] copy3 = Arrays.copyOfRange(arr, 1, 3);   // [2, 8]

// 排序 + 查找
int[] sorted = {1, 2, 5, 8, 9};
Arrays.sort(arr);                         // 原地升序
int idx = Arrays.binarySearch(sorted, 5); // 2（必须是有序数组）

===== 7. 数组与 Arrays 工具类 =====
排序后: [1, 2, 5, 8, 9]
5 8 9 ← 增强 for-each 遍历

int[][] grid = new int[3][4];          // 3 行 4 列
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
};

for (int[] row : matrix) {             // 逐行遍历
    for (int v : row) System.out.print(v + " ");
}

public class Account {
    private String owner;      // 字段（状态）
    private double balance;

    public Account(String owner) {   // 构造方法（和类同名、无返回值）
        this.owner = owner;
    }

    public void deposit(double amount) {   // 方法（行为）
        this.balance += amount;
    }
}

Account acc = new Account("张三");   // 造对象
acc.deposit(100);                    // 发消息（调方法）

// ① 方法重载（overload）：同名，参数列表不同 —— 编译器按"传的实参"选方法
public int add(int a, int b)        { return a + b; }
public int add(int a, int b, int c) { return a + b + c; }
public double add(double a, double b) { return a + b; }

// ② 可变参数（varargs）：最后一个参数可以传 0~N 个
public int sum(int... nums) {
    int s = 0;
    for (int n : nums) s += n;    // nums 在方法内是 int[]
    return s;
}
sum();          // 0
sum(1, 2, 3);   // 6

// ③ 递归：方法调用自己 —— 必须有"终止条件"，否则 StackOverflowError
public int factorial(int n) {
    if (n <= 1) return 1;         // 终止条件
    return n * factorial(n - 1);  // 向终止条件收敛
}
factorial(5);   // 120

public class User {
    private String name;
    private int age;

    // ① 重载的构造器 + this() 调用兄弟构造器（必须是第一行）
    public User() {
        this("匿名", 0);
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Account {
    private double balance;   // private：外部直接看不到

    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("金额必须为正数!");   // 受控入口做校验
        }
        this.balance += amount;
    }

    public double getBalance() { return balance; }
}

===== 1. 封装: 数据只能通过受控方法访问 =====
存取后: Account{owner='张三', balance=150.0}
拦截非法操作: 金额必须为正数!   ← 封装的意义

public class Animal {
    protected String name;
    public void eat() { System.out.println(name + " 吃东西"); }
}

public class Dog extends Animal {          // extends = 继承
    @Override                              // 注解：让编译器检查你是不是真的在重写
    public void eat() {
        super.eat();                       // super = 父类
        System.out.println(name + " 啃骨头");
    }
}

Shape sh = new Circle(2);   // 编译时看 Shape, 运行时看 Circle
sh.area();                  // 动态绑定 → 实际执行 Circle.area()

===== 2. 多态: 同一行代码, 不同对象不同行为 =====
  圆形     面积 = 12.57
  矩形     面积 = 12.00
  三角形    面积 = 6.00
总面积 = 30.57   ← 循环里没有一行 if/else, 全靠多态

public class Shape {
    static int count = 0;     // 静态字段：所有对象共享一份

    public Shape() {
        count++;              // 每 new 一个对象，计数 +1
    }

    static void printTotal() {   // 静态方法：没有 this，只能访问静态成员
        System.out.println("已创建 " + count + " 个图形");
    }
}

===== 4. static: 属于类, 不属于对象 =====
已创建的图形总数: 3   ← 类名直接访问静态字段

// 抽象类："是什么" —— 单继承，可以有状态
public abstract class Shape {
    abstract double area();               // 抽象方法：子类必须实现
    void describe() { System.out.println("面积=" + area()); }  // 具体方法：可复用
}

// 接口："能做什么" —— 多实现，JDK8+ 也可以有默认方法
public interface WithCorners {
    int corners();                        // 抽象方法
    default boolean isPolygon() {         // 默认方法（接口也能"进化"了）
        return corners() >= 3;
    }
}

public class Triangle extends Shape implements WithCorners {
    double area() { return 6; }
    public int corners() { return 3; }
}

===== 3. 接口: 描述'能力' (抽象类描述'是什么') =====
  矩形 有 4 条边
  三角形 有 3 条边

public class Person {
    private String name;
    private int age;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;                       // ① 同一引用直接 true
        if (o == null || getClass() != o.getClass()) return false;  // ② 类型不符 false
        Person p = (Person) o;                            // ③ 逐字段比较
        return age == p.age && Objects.equals(name, p.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);                   // ④ 和 equals 用同一组字段
    }
}

自动 toString : Point[x=3, y=4]
自动 equals   : p1.equals(p2) = true

public class Outer {

    class Inner {}                 // ① 成员内部类（持有外部类引用）
    static class Nested {}         // ② 静态嵌套类（不持有外部引用）

    void method() {
        class Local {}             // ③ 局部内部类（方法内）

        Runnable r = new Runnable() {   // ④ 匿名内部类（没名字，就地实现）
            @Override
            public void run() { System.out.println("run"); }
        };
    }
}

public enum OrderStatus {
    CREATED("已创建"), PAID("已支付"), CANCELED("已取消");

    private final String label;
    OrderStatus(String label) { this.label = label; }
    public String getLabel() { return label; }
}

OrderStatus s = OrderStatus.PAID;
s.name();             // "PAID"（名字）
s.ordinal();          // 1（序号）
s == OrderStatus.PAID // true —— 枚举天生单例，用 == 安全
switch (s) { case PAID -> System.out.println("处理支付"); default -> {} }

package com.example.app;      // 包声明：文件第一行

import java.util.List;        // 导入其他包的类

String s = "Hello";

// 查询类
s.length()            // 5
s.charAt(1)           // 'e'
s.indexOf("l")        // 2（首次出现位置）
s.lastIndexOf("l")    // 3
s.contains("ell")     // true
s.startsWith("He")    // true
s.endsWith("lo")      // true
s.isEmpty()           // false
s.isBlank()           // false（JDK11+，空白字符也算空）

// 转换类（都返回新字符串）
s.toUpperCase()             // HELLO
s.toLowerCase()             // hello
s.substring(1, 4)           // "ell"（左闭右开！）
s.replace("l", "L")         // HeLLo
s.trim()                    // 去首尾空白（旧）
s.strip()                   // 去首尾空白（新，支持 Unicode）

// 分割与拼接
"a,b,c".split(",")          // ["a", "b", "c"]
String.join("-", "a", "b")  // "a-b"
String.format("%s: %d 岁", "张三", 18)   // "张三: 18 岁"

// 比较
"abc".equals("abc")         // true（永远用 equals）
"ABC".equalsIgnoreCase("abc") // true
"apple".compareTo("banana") // 负数（字典序）

s1 == s2        : true   ← 同一常量池对象, 地址相同
s1 == s3        : false   ← new 出来的不同对象
s1.equals(s3)   : true    ← 比较内容, 永远用 equals
s1 == s3.intern(): true   ← intern() 把字符串'放回池'

StringBuilder sb = new StringBuilder();
sb.append("Hello").append(", ").append("Java");   // 链式调用
sb.insert(0, ">> ");          // 插入
sb.reverse();                 // 反转
String result = sb.toString();   // 最终一次性转成 String

// 基本类型 ↔ 包装类（自动装箱/拆箱）
Integer i = 100;      // 自动装箱（int → Integer）
int j = i;            // 自动拆箱（Integer → int）

// 常用方法
Integer.parseInt("123")       // 字符串 → int（最常用！）
Integer.valueOf("123")        // 字符串 → Integer
Integer.MAX_VALUE             // 2147483647
Integer.toBinaryString(12)    // "1100"
Double.isNaN(0.0 / 0)         // true

127 == 127 : true   ← 缓存 [-128,127] 内, 是同一对象
128 == 128 : false   ← 超出缓存, 是不同对象
结论: 包装类比较永远用 .equals() !

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
System.out.println(a.add(b));       // 0.3（精确！）

// 陷阱：别用 new BigDecimal(0.1)（传入 double 本身就不精确），要用字符串构造
// 运算 API：add / subtract / multiply / divide
BigDecimal div = new BigDecimal("10").divide(new BigDecimal("3"), 2, RoundingMode.HALF_UP); // 3.33

// 比较大小：用 compareTo（equals 会连精度一起比："1.0" != "1.00"）
new BigDecimal("1.0").compareTo(new BigDecimal("1.00"))  // 0（相等）

0.1 + 0.2 = 0.30000000000000004   ← 不等于 0.3!
BigDecimal: 0.1 + 0.2 = 0.3       ← 金额必须这样算

Math.abs(-5)        // 5
Math.max(3, 7)      // 7
Math.min(3, 7)      // 3
Math.round(3.6)     // 4（四舍五入到 long）
Math.floor(3.7)     // 3.0（向下取整）
Math.ceil(3.2)      // 4.0（向上取整）
Math.pow(2, 10)     // 1024.0
Math.sqrt(16)       // 4.0
Math.random()       // [0.0, 1.0) 随机小数

// 新版随机数（JDK17+ 推荐 RandomGenerator，老代码常见 Random）
Random r = new Random();
r.nextInt(100)            // [0, 100) 随机整数
r.nextInt(1, 7)           // [1, 7) 骰子点数

// ① 本地日期/时间
LocalDate date = LocalDate.now();                    // 2026-09-20
LocalTime time = LocalTime.now();                    // 08:30:15.123
LocalDateTime dateTime = LocalDateTime.now();        // 2026-09-20T08:30:15.123

LocalDate d = LocalDate.of(2026, 9, 20);             // 构造
d.plusDays(7);      // 加天数（返回新对象，原对象不变！）
d.minusMonths(1);   // 减月份
d.getYear(); d.getMonthValue(); d.getDayOfWeek();    // 拆字段

// ② 格式化 / 解析
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String text = fmt.format(LocalDateTime.now());        // "2026-09-20 08:30:15"
LocalDate parsed = LocalDate.parse("2026-09-20");     // 解析

// ③ 时间戳与机器时间
Instant now = Instant.now();                          // UTC 瞬间
long millis = now.toEpochMilli();                     // 毫秒时间戳

// ④ 时间间隔
long days = ChronoUnit.DAYS.between(start, end);      // 两个日期差几天
Duration duration = Duration.between(startTime, endTime);   // 时长（秒/纳秒）

现在  : 2026-09-20 00:58:54
一周后: 2026-09-27（相差 7 天）
时间戳: 1789865934259 ms（Instant = 机器时间视角）

Objects.requireNonNull(user, "user 不能为 null");   // 参数校验（快速失败）
Objects.equals(a, b);                              // 空安全的 equals
Objects.hash(name, age);                           // 生成 hashCode
Objects.isNull(x); Objects.nonNull(x);

System.currentTimeMillis();      // 毫秒时间戳
System.arraycopy(src, 0, dst, 0, n);   // 高性能数组复制
System.getenv("PATH");           // 读环境变量
System.exit(0);                  // 退出（谨慎！）

Collection
├── List (有序, 可重复): ArrayList / LinkedList
├── Set  (去重):        HashSet / LinkedHashSet / TreeSet
└── Queue (队列):       ArrayDeque / PriorityQueue

Map (键值对):           HashMap / LinkedHashMap / TreeMap / ConcurrentHashMap

===== 1. List / Set / Map 三兄弟 =====
List (有序, 可重复): [苹果, 香蕉, 苹果]
Set  (去重):        [苹果, 香蕉]
Map  (键→值):       {苹果=5, 香蕉=3},  取苹果=5

List<String> list = new ArrayList<>();
list.add("a"); list.add("b"); list.add("a");
list.get(0);             // "a" —— 随机访问
list.size();             // 3（可以有重复！）
list.contains("b");      // true
list.indexOf("a");       // 0
list.remove("a");        // 删第一个 "a"
list.set(0, "x");        // 替换下标 0
List.of("a", "b");       // 创建不可变 List（JDK9+，推荐做常量）

Set<String> set = new HashSet<>();
set.add("a"); set.add("a"); set.add("b");
set.size();        // 2（自动去重！）
set.contains("a"); // true（O(1) 查找）

Map<String, Integer> map = new HashMap<>();
map.put("语文", 90);
map.put("数学", 95);
map.get("语文");              // 90
map.getOrDefault("英语", 0);  // 0（无 key 时的默认值，防 NPE）
map.containsKey("数学");      // true
map.keySet();                 // [语文, 数学]
map.values();                 // [90, 95]
map.forEach((k, v) -> System.out.println(k + " → " + v));   // 最顺的遍历

// 复合操作（原子风格，简洁且不易错）
map.putIfAbsent("英语", 88);                    // 不存在才放
map.computeIfAbsent("物理", k -> 80);           // 不存在才计算放入
map.merge("语文", 5, Integer::sum);             // 存在则合并：90+5

===== 5. 遍历 Map 的正确姿势 =====
  苹果 → 5
  香蕉 → 3

// 队列：先进先出（FIFO）—— 任务排队、消息缓冲
Queue<String> queue = new ArrayDeque<>();
queue.offer("任务1");    // 入队（尾部）
queue.poll();            // 出队（头部），空则返回 null
queue.peek();            // 看一眼队头，不出队

// Deque：双端队列 —— 可以当"栈"用（后进先出 LIFO）
Deque<Integer> stack = new ArrayDeque<>();
stack.push(1);       // 压栈
stack.push(2);
stack.pop();         // 2（后进的先出）

// ① 泛型类
public class Box<T> {
    private T value;
    public void set(T value) { this.value = value; }
    public T get() { return value; }
}
Box<String> box = new Box<>();   // T 被"绑定"为 String
box.set("hello");                // box.set(1) 编译期直接报错！

// ② 泛型方法
public static <T> T firstOrNull(List<T> list) {
    return list.isEmpty() ? null : list.get(0);
}

// ③ 通配符与 PECS 原则
void printAll(List<? extends Number> src) {}   // 生产者-extends：只读
void addAll(List<? super Integer> dst) {}      // 消费者-super：只写

===== 2. 泛型: 编译期类型约束 =====
已添加 5 个人 (放错类型编译期就报错)

// ① 类实现 Comparable：定义"自然顺序"
public class Person implements Comparable<Person> {
    private int age;
    @Override
    public int compareTo(Person o) {
        return Integer.compare(this.age, o.age);   // 按年龄升序
    }
}
Collections.sort(persons);   // 直接用

// ② 外部 Comparator：定义"临时规则"，不改类
persons.sort(Comparator.comparingInt(Person::getAge));              // 年龄升序
persons.sort(Comparator.comparing(Person::getName).reversed());     // 名字降序
persons.sort(Comparator.comparing(Person::getCity)
                        .thenComparing(Person::getName));           // 多级排序

// ③ 按城市分组计数（Demo3 的进阶确认）
Map<String, Long> byCity = persons.stream()
        .collect(Collectors.groupingBy(Person::getCity, Collectors.counting()));

Collections.sort(list);                      // 排序
Collections.reverse(list);                   // 反转
Collections.shuffle(list);                   // 打乱
Collections.max(list); Collections.min(list);   // 最值
Collections.unmodifiableList(list);          // 只读视图（防外部改动）
Collections.emptyList();                     // 空集合常量
Collections.swap(list, i, j);                // 交换

===== 6. 迭代时删除元素陷阱 =====
  抛出了: ConcurrentModificationException   ← 迭代中修改集合的著名陷阱
  removeIf 后: [苹果, 橘子, 葡萄]

Throwable
├── Error                    (系统级, 一般不处理: OOM / StackOverflowError)
└── Exception
    ├── RuntimeException     (非受检: NullPointerException / 越界 / 算术异常)
    └── 其他                 (受检: IOException / SQLException, 必须处理)

try {
    int r = 10 / divisor;
    System.out.println("结果: " + r);
} catch (ArithmeticException | IllegalArgumentException e) {   // 多重 catch（JDK7+）
    System.out.println("参数问题: " + e.getMessage());
} catch (Exception e) {
    System.out.println("兜底: " + e);
} finally {
    System.out.println("无论成败都执行（清理现场）");
}

try (Connection conn = DriverManager.getConnection(url);
     PreparedStatement ps = conn.prepareStatement(sql)) {
    // 代码块结束时，ps、conn 自动 close（逆序关闭）
} catch (SQLException e) {
    // 处理
}

// throw：抛出一个异常对象（动作）
if (amount <= 0) {
    throw new IllegalArgumentException("金额必须为正数: " + amount);
}

// throws：在方法签名上声明"我可能抛出什么"（契约）
public String readFile(String path) throws IOException { ... }

// 自定义异常：带上业务语义
public class BizException extends RuntimeException {
    private final int httpCode;
    public BizException(int httpCode, String message) {
        super(message);
        this.httpCode = httpCode;
    }
    public int httpCode() { return httpCode; }
}

try {
    dao.insert(order);
} catch (SQLException e) {
    throw new BizException(500, "保存订单失败: orderId=" + order.id()).initCause(e);
    // 或 new BizException(...) 里传 e：new BizException(500, msg, e)
}

// 读文件（缓冲流包装，减少系统调用）
try (var in = new BufferedInputStream(new FileInputStream("photo.jpg"))) {
    int b;
    while ((b = in.read()) != -1) {   // 逐字节（演示用；实际会配 byte[] 缓冲）
        // 处理
    }
}

// 写文件
try (var out = new BufferedOutputStream(new FileOutputStream("copy.jpg"))) {
    out.write(new byte[]{1, 2, 3});
}

// 读文本（InputStreamReader 负责"字节 → 字符"的解码）
try (var reader = new BufferedReader(
        new InputStreamReader(new FileInputStream("data.txt"), StandardCharsets.UTF_8))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
}

// 写文本
try (var writer = new BufferedWriter(new FileWriter("out.txt", StandardCharsets.UTF_8))) {
    writer.write("第一行");
    writer.newLine();
}

Path path = Path.of("data", "config.txt");       // 拼路径（跨平台安全）

// 一行读写
Files.writeString(path, "orders=42\n", StandardCharsets.UTF_8);
String content = Files.readString(path, StandardCharsets.UTF_8);

// 存在性 / 属性
Files.exists(path);          Files.size(path);
Files.createDirectories(Path.of("data", "logs"));   // 建多级目录

// 复制 / 移动 / 删除
Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);
Files.move(src, dst, StandardCopyOption.REPLACE_EXISTING);
Files.deleteIfExists(path);

// 大文件流式处理（不会一次性读进内存）
try (var lines = Files.lines(Path.of("big.txt"))) {
    lines.filter(s -> s.contains("Java")).forEach(System.out::println);
}

// 遍历目录
try (var stream = Files.list(Path.of("."))) {     // 一层
    stream.filter(Files::isRegularFile).forEach(System.out::println);
}
try (var walk = Files.walk(Path.of("src"))) {     // 递归所有层
    walk.filter(p -> p.toString().endsWith(".java")).forEach(System.out::println);
}

// ① Java 原生序列化：对象 ↔ 字节流（要求类 implements Serializable）
try (var out = new ObjectOutputStream(new FileOutputStream("user.ser"))) {
    out.writeObject(new User("张三", 18));
}
try (var in = new ObjectInputStream(new FileInputStream("user.ser"))) {
    User user = (User) in.readObject();
}

// ① 继承 Thread（不推荐，占用继承位）
class MyThread extends Thread {
    public void run() { System.out.println("跑"); }
}
new MyThread().start();

// ② 实现 Runnable（推荐，接口不占继承）
Runnable task = () -> System.out.println("跑");
new Thread(task).start();

// ③ 实现 Callable + FutureTask（有返回值、能抛异常）
Callable<Integer> c = () -> 42;
FutureTask<Integer> ft = new FutureTask<>(c);
new Thread(ft).start();
int result = ft.get();      // 阻塞拿结果：42

NEW → RUNNABLE → (BLOCKED / WAITING / TIMED_WAITING) → TERMINATED

Thread t = new Thread(() -> {
    try { Thread.sleep(1000); } catch (InterruptedException e) { /* 恢复策略 */ }
    System.out.println("后台任务完成");
});
t.start();
t.join();          // 等它完成
System.out.println("主线程继续");

// ① synchronized：互斥锁（最常用）
private synchronized void inc() { count++; }          // 方法级
private final Object lock = new Object();
void inc2() { synchronized (lock) { count++; } }      // 代码块级（锁对象显式）

// ② Lock：显式锁，更灵活（可尝试、可超时、可公平）
private final ReentrantLock lock = new ReentrantLock();
void inc3() {
    lock.lock();
    try { count++; } finally { lock.unlock(); }       // 必须在 finally 里解锁！
}

// ③ volatile：保证"可见性"（一个线程改了，另一个立刻看见）+ 禁止指令重排
//    但【不保证原子性】——count++ 用 volatile 依然会错！
private volatile boolean running = true;

// ④ 原子类：CAS 无锁编程
private final AtomicInteger count2 = new AtomicInteger();
void inc4() { count2.incrementAndGet(); }             // 线程安全的自增

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();   // 并发 Map
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();     // 读多写少
BlockingQueue<String> queue = new LinkedBlockingQueue<>();            // 生产者-消费者
queue.put("任务");      // 满则阻塞
String task = queue.take();   // 空则阻塞

CountDownLatch latch = new CountDownLatch(3);   // 等 3 件事都完成

ThreadPoolExecutor pool = new ThreadPoolExecutor(
        4,                                  // 核心线程数
        8,                                  // 最大线程数
        60L, TimeUnit.SECONDS,              // 空闲回收时间
        new ArrayBlockingQueue<>(100),      // 有界队列（防 OOM）
        new ThreadPoolExecutor.CallerRunsPolicy());  // 拒绝策略

pool.execute(() -> System.out.println("任务执行"));

// 提交有返回值的任务
Future<Integer> f = pool.submit(() -> 1 + 1);
int r = f.get();           // 2

pool.shutdown();           // 优雅关闭：不再收新任务，等旧任务跑完

// 获取 Class 对象的三种方式
Class<?> c1 = String.class;                  // 类名.class
Class<?> c2 = "hello".getClass();            // 对象.getClass()
Class<?> c3 = Class.forName("java.lang.String");   // 全限定名（框架最爱）

System.out.println(c1 == c2 && c2 == c3);    // true —— 同一个类只有一份 Class 对象

Class<?> clazz = Class.forName("com.example.User");

// ① 构造对象
Object user = clazz.getDeclaredConstructor().newInstance();   // 无参
Constructor<?> ctor = clazz.getDeclaredConstructor(String.class, int.class);
Object user2 = ctor.newInstance("张三", 18);

// ② 查看/调用方法
for (Method m : clazz.getDeclaredMethods()) {
    System.out.println(m.getName());     // 打印所有方法名
}
Method setName = clazz.getMethod("setName", String.class);
setName.invoke(user, "李四");            // 相当于 user.setName("李四")

// ③ 查看/修改字段（包括 private！）
Field f = clazz.getDeclaredField("age");
f.setAccessible(true);                   // 打破封装（谨慎）
f.set(user, 20);
Object age = f.get(user);                // 20

// ① 内置注解
@Override          // 编译期检查重写
@Deprecated        // 标记"过时"
@SuppressWarnings("unchecked")   // 抑制警告

// ② 元注解（注解的注解）
@Target({ElementType.METHOD, ElementType.TYPE})   // 能贴在哪
@Retention(RetentionPolicy.RUNTIME)               // 保留到什么时候（RUNTIME 才能被反射读到）
public @interface MyLog {
    String value() default "默认值";               // 注解属性
}

// ③ 使用
@MyLog("下单操作")
public void placeOrder() { ... }

// ④ 反射读取（框架的"读标签"过程）
Method m = clazz.getMethod("placeOrder");
if (m.isAnnotationPresent(MyLog.class)) {
    MyLog log = m.getAnnotation(MyLog.class);
    System.out.println("操作名: " + log.value());   // 下单操作
}

// 接口 + 调用处理器 = 运行期生成代理类
Object proxy = Proxy.newProxyInstance(
        clazz.getClassLoader(),
        new Class[]{Service.class},
        (p, method, args) -> {
            System.out.println("[前置] 日志/事务开始");
            Object result = method.invoke(target, args);   // 调真实方法
            System.out.println("[后置] 日志/事务提交");
            return result;
        });

// 老写法：匿名内部类（还记得第 5 章吗）
Runnable r1 = new Runnable() {
    @Override
    public void run() { System.out.println("跑"); }
};

// 新写法：lambda（JDK8+）—— 因为接口只有一个抽象方法，编译器能推断出你在实现谁
Runnable r2 = () -> System.out.println("跑");

square.apply(9)      = 81
notBlank.test(" ")   = false
supplier.get()       = supplied
consumer + 方法引用输出这一行

Function<Integer, Integer> square = x -> x * x;       // 输入一个，输出一个
Predicate<String> notBlank = s -> !s.isBlank();       // 判断
Supplier<String> supplier = () -> "supplied";         // 无中生有
Consumer<String> printer = System.out::println;       // 消费掉

// 扩展：基本类型特化版（避免装箱开销）：IntFunction、ToIntFunction、IntPredicate...
// 还有：BiFunction<T,U,R>（两入一出）、UnaryOperator<T>（入出同型）

Integer::parseInt 方法引用 → [1, 2, 3]
四种方法引用：类::静态 / 对象::实例 / 类::实例 / 类::new

// 给集合排序
list.sort((a, b) -> a.age() - b.age());               // 或者 Comparator.comparingInt(Person::age)

// 按钮回调（Swing/JavaFX——上位机界面常用）
button.addActionListener(e -> System.out.println("点击!"));

// 线程任务
new Thread(() -> System.out.println("异步跑")).start();

数据源 → [filter] → [map] → [sorted] → [collect] → 结果
        中间操作    中间操作   中间操作    终止操作

===== 3. Lambda + Stream: 声明式数据流水线 =====
北京成人(按年龄): 孙七, 张三, 王五
  对比: 如果用 for 循环 + if, 这段要写十几行

List<Person> persons = ...;

// 完整流水线：筛选 30 岁以下 → 取名字 → 排序 → 收集
List<String> names = persons.stream()             // ① 数据源
        .filter(p -> p.age() < 30)                 // ② 中间操作（惰性！）
        .map(Person::name)                        //    转换
        .sorted()                                 //    排序
        .toList();                                // ③ 终止操作（这时才真正执行）

// 常用中间操作
stream.distinct()          // 去重
      .limit(5)            // 取前 5 个
      .skip(2)             // 跳过前 2 个
      .flatMap(s -> Arrays.stream(s.split(",")))   // 打平（一对多）

// 常用终止操作
stream.count()                       // 计数
      .anyMatch(s -> s.startsWith("A"))   // 存在一个满足？（短路）
      .allMatch(...)                 // 全部满足？
      .findFirst()                   // 取第一个（Optional）
      .reduce(0, Integer::sum)       // 归约（求和/求积/最值）
      .forEach(System.out::println); // 逐个消费

工资≥15000（降序）: [张三, 李四, 赵六, 王五]
部门平均工资: {研发=19000.0, 运维=12000.0, 销售=15500.0}
工资总和: 81000
名字→工资: {钱七=12000, 李四=18000, 张三=20000, 王五=15000, 赵六=16000}

// 下面是产生上面输出的代码形状
var topNames = staff.stream()
        .filter(e -> e.salary() >= 15000)
        .sorted(Comparator.comparingInt(Employee::salary).reversed())
        .map(Employee::name)
        .toList();

Map<String, Double> avgByDept = staff.stream()
        .collect(Collectors.groupingBy(Employee::dept,
                 Collectors.averagingInt(Employee::salary)));       // 分组统计

int sum = staff.stream().mapToInt(Employee::salary).sum();          // 基本类型流（避免装箱）

Map<String, Integer> salaryMap = staff.stream()
        .collect(Collectors.toMap(Employee::name, Employee::salary));// 收集成 Map

timeout = 3000, retries = 默认值
host 缺失，走降级逻辑
链式风格：user.getAddr().map(Addr::city).orElse("未知")

// 创建
Optional<String> full = Optional.of("值");             // 值不能为 null
Optional<String> maybe = Optional.ofNullable(getFromMap());   // 可能为 null
Optional<String> empty = Optional.empty();

// 常用 API
maybe.orElse("默认值")              // 无值用默认
     .orElseGet(() -> compute())    // 无值才计算（省性能）
     .orElseThrow(() -> new IllegalStateException("缺失"));   // 无值抛异常
maybe.ifPresent(v -> System.out.println(v));                // 有值才执行
maybe.ifPresentOrElse(v -> print(v), () -> fallback());     // 两分支
maybe.map(String::length)          // 有值则转换（链式）
     .filter(len -> len > 3);      // 有值则过滤

// 从可能为 null 的链式调用中优雅取值的对照：
// 旧：if (user != null && user.getAddr() != null && user.getAddr().getCity() != null) ...
// 新：Optional.ofNullable(user).map(User::getAddr).map(Addr::city).orElse("未知")