Java 程序设计：
从面向对象思想到现代 Java 实战

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

# 1. 用编辑器写 HelloWorld.java（注意：文件名必须与 public class 同名）
$ vim HelloWorld.java

# 2. 编译：javac 把 .java 编译成 .class
$ javac HelloWorld.java
$ ls
HelloWorld.class  HelloWorld.java

# 3. 运行：java 启动 JVM，加载字节码并执行
$ java HelloWorld
Hello, World!

# 常见编译错误示例
$ java HelloWorld.java       # ❌ 不要加 .java 后缀
错误: 找不到或无法加载主类 HelloWorld.java

// package 语句（可选）：类的所属包
package com.example.lesson;

// import 语句（可选）：引入其他包的类
import java.util.Scanner;

// public class：每个 .java 文件最多一个 public 类，文件名必须与之相同
public class Main {
    // main 方法：程序入口
    public static void main(String[] args) {
        // 语句
        System.out.println("Hello");
    }
}

// 单行注释：到行尾结束

/*
 * 多行注释：跨越多行
 * 可用于临时屏蔽代码块
 */

/**
 * 文档注释（Javadoc）：用于生成 API 文档
 * @param x 参数说明
 * @return 返回值说明
 */
public int foo(int x) { return x * 2; }

// 变量：值可以变
int    age   = 18;
double score = 95.5;
char   grade = 'A';
String name  = "Java";

// 常量：用 final 修饰（必须初始化）
final double PI  = 3.14159;
final int    MAX = 100;
// PI = 3.14;     // ❌ 编译错误：不能修改 final 变量

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 输出
        System.out.print("不换行");
        System.out.println("自动换行");
        System.out.printf("姓名=%s, 年龄=%d\n", "Alice", 20);

        // 输入（从标准输入读）
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入姓名：");
        String name = sc.nextLine();      // 读整行（含空格）

        System.out.print("请输入年龄：");
        int age = sc.nextInt();           // 读整数

        System.out.printf("你好 %s，你 %d 岁\n", name, age);
        sc.close();
    }
}

int     a = 10;                  // 基本类型，存 10
String s = "Hello";            // 引用类型，存的是字符串对象的地址

int     b = a;                  // 值拷贝：b 也等于 10
String t = s;                  // 地址拷贝：t 与 s 指向同一对象

// 1) 自动转换：小 → 大（安全）
int    i = 100;
double d = i;                  // 100 → 100.0

// 2) 强制转换：大 → 小（可能丢失精度）
double d2 = 3.99;
int    i2 = (int) d2;            // 3（直接截断，不四舍五入）

// 3) 字符串与数字互转
String s1 = String.valueOf(42);   // int → String
int    i3 = Integer.parseInt("123"); // String → int

if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 60) {
    grade = "C";
} else {
    grade = "D";
}

// 传统 switch：每个 case 需要 break
switch (day) {
    case 1: print("Mon"); break;
    case 2: print("Tue"); break;
    default: print("Other");
}

// Java 14+ switch 表达式：返回值，更安全（无穿透）
String name = switch (day) {
    case 1 -> "Mon";
    case 2 -> "Tue";
    case 3, 4, 5 -> "Midweek";     // 多值合并
    default -> "Weekend";
};

// while
int i = 0;
while (i < 5) {
    System.out.println(i++);
}

// do-while：至少执行一次
int n;
do {
    System.out.print("输入正数：");
    n = sc.nextInt();
} while (n <= 0);

// 经典 for
for (int j = 0; j < 5; j++) {
    System.out.println(j);
}

// 增强 for（foreach）：遍历数组或集合
int[] nums = {1, 2, 3, 4, 5};
for (int x : nums) {
    System.out.println(x);
}

import java.util.Scanner;
import java.util.Random;

public class GuessNumber {
    public static void main(String[] args) {
        Random r = new Random();
        int target = r.nextInt(100) + 1;     // 1~100
        Scanner sc = new Scanner(System.in);
        int guess, tries = 0;

        do {
            System.out.print("猜一个 1-100 的数：");
            guess = sc.nextInt();
            tries++;
            if (guess > target)      System.out.println("大了！");
            else if (guess < target) System.out.println("小了！");
        } while (guess != target);

        System.out.printf("用了 %d 次猜中！\n", tries);
    }
}

// 三种声明方式（推荐第一种）
int[] scores = new int[5];            // 默认 0
int[] ages   = {18, 20, 22};    // 静态初始化
String[] names = new String[]{"A","B"};

// 访问 / 遍历
ages[0] = 25;
System.out.println(ages.length);    // 数组长度（属性，非方法）

for (int x : ages) {
    System.out.println(x);
}

// Arrays 工具类
import java.util.Arrays;
Arrays.sort(ages);                    // 升序排序
System.out.println(Arrays.toString(ages));

int[][] matrix = {
    {1, 2,  3},
    {4, 5,  6},
    {7, 8,  9}
};

for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}

String s = "Hello, Java!";

// 常用方法
System.out.println(s.length());              // 12
System.out.println(s.charAt(0));           // 'H'
System.out.println(s.substring(0, 5));      // "Hello"
System.out.println(s.indexOf("Java"));      // 7
System.out.println(s.contains("Java"));     // true
System.out.println(s.startsWith("Hi"));    // false
System.out.println(s.replace("Java", "World")); // 新字符串对象
System.out.println(s.split(", ")[0]);      // "Hello"

// 字符串比较：必须用 equals
String a = "java", b = "JAVA";
a.equals(b);                 // false（区分大小写）
a.equalsIgnoreCase(b);      // true
// a == b  // ❌ 比较地址，可能为 false

// ❌ 低效：每次 + 都创建新 String 对象
String s = "";
for (int i = 0; i < 1000; i++) s = s + i;

// ✔ 高效：使用 StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) sb.append(i);
String result = sb.toString();

public class MethodDemo {
    // 无返回值
    public static void sayHi(String name) {
        System.out.println("Hi, " + name);
    }

    // 有返回值
    public static int add(int a, int b) {
        return a + b;
    }

    // 方法重载：同名不同参
    public static double add(double a, double b) {
        return a + b;
    }

    // 可变参数（必须是最后一个参数）
    public static int sum(int... nums) {
        int total = 0;
        for (int n : nums) total += n;
        return total;
    }

    public static void main(String[] args) {
        sayHi("Alice");
        System.out.println(add(3, 5));         // 8
        System.out.println(sum(1, 2, 3, 4, 5)); // 15
    }
}

// 1) 基本类型：完全拷贝，互不影响
static void swapInt(int a, int b) {
    int t = a; a = b; b = t;   // 仅在方法内交换
}

// 2) 引用类型：可以修改对象内容，但不能改变原引用指向
static void modify(int[] arr) {
    arr[0] = 999;            // ✔ 修改原数组元素
}

static long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// Fibonacci：朴素递归效率极低，实际应用应改用迭代
static long fib(int n) {
    if (n < 2) return n;
    return fib(n - 1) + fib(n - 2);
}

// 迭代版 Fibonacci：O(n) 时间，O(1) 空间
static long fibIter(int n) {
    if (n < 2) return n;
    long a = 0, b = 1;
    for (int i = 2; i <= n; i++) {
        long c = a + b; a = b; b = c;
    }
    return b;
}

public class Student {
    // 成员变量（字段）—— 推荐 private
    private String name;
    private int    age;
    private double score;

    // 构造方法（Constructor）：用于初始化对象
    public Student() {
        this("Unknown", 0, 0.0);              // 调用其他构造
    }

    public Student(String name, int age) {
        this(name, age, 0.0);
    }

    public Student(String name, int age, double score) {
        this.name  = name;
        this.age   = age;
        this.score = score;
    }

    // 公开方法
    public void study() {
        System.out.println(name + " 在学习");
    }

    public void printInfo() {
        System.out.printf("%s, %d 岁, %.1f 分%n", name, age, score);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象：new 调用构造方法
        Student s1 = new Student();                          // 调用无参构造
        Student s2 = new Student("Alice", 20, 95.5);    // 调用带参构造

        s2.study();
        s2.printInfo();
    }
}

public class Account {
    private String owner;
    private double balance;       // 余额：必须保持非负

    public Account(String owner, double init) {
        this.owner   = owner;
        this.balance = init >= 0 ? init : 0;
    }

    // 通过 getter 读，通过 setter 受控地写
    public String getOwner()   { return owner; }
    public double getBalance() { return balance; }

    // 业务方法：体现"行为"
    public void deposit(double amount) {
        if (amount <= 0) throw new IllegalArgumentException("金额必须为正");
        balance += amount;
    }

    public void withdraw(double amount) {
        if (amount > balance) throw new IllegalArgumentException("余额不足");
        balance -= amount;
    }
}

public class Counter {
    public static int totalCount = 0;     // 类变量：所有对象共享
    public static final String VERSION = "1.0"; // 类常量

    private int id;

    public Counter() {
        totalCount++;
        this.id = totalCount;
    }

    // 静态方法：不能访问实例成员
    public static int getTotal() { return totalCount; }
}

// 使用
System.out.println(Counter.VERSION);       // 1.0  （类名.常量）
new Counter();
new Counter();
System.out.println(Counter.getTotal());  // 2

// 父类
public class Person {
    protected String name;
    protected int    age;

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

    public void sayHi() {
        System.out.println("Hi, 我叫 " + name);
    }
}

// 子类
public class Student extends Person {
    private String school;

    public Student(String name, int age, String school) {
        super(name, age);              // 调用父类构造（必须第一句）
        this.school = school;
    }

    @Override                    // 方法重写（覆盖父类）
    public void sayHi() {
        super.sayHi();               // 调用父类版本
        System.out.println("我在 " + school + " 上学");
    }
}

class Animal {
    public void sound() {
        System.out.println("...");
    }
}

class Dog extends Animal {
    @Override                     // 强烈推荐：编译器会校验
    public void sound() {
        System.out.println("汪汪！");
    }
}

class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("喵喵！");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        // 父类引用 → 子类对象
        Animal a1 = new Dog();
        Animal a2 = new Cat();

        makeSound(a1);   // 汪汪！
        makeSound(a2);   // 喵喵！

        // 多态数组：处理一组"形状"
        Animal[] animals = {new Dog(), new Cat(), new Animal()};
        for (Animal a : animals) a.sound();
    }

    // 接受父类引用：实际执行子类的方法
    static void makeSound(Animal a) {
        a.sound();
    }
}

public abstract class Shape {
    protected String color;

    public Shape(String color) { this.color = color; }

    // 抽象方法：只有签名，没有实现
    public abstract double area();
    public abstract double perimeter();

    // 普通方法可以保留
    public String getColor() { return color; }
}

public class Circle extends Shape {
    private double r;
    public Circle(String color, double r) {
        super(color); this.r = r;
    }
    @Override public double area()      { return 3.14159 * r * r; }
    @Override public double perimeter() { return 2 * 3.14159 * r; }
}

// Shape s = new Shape();   // ❌ 不能实例化抽象类
Shape s = new Circle("Red", 2.0);    // ✔ 多态

// 接口：只声明"做什么"，不写"怎么做"
public interface Flyable {
    void fly();                  // 默认 public abstract

    // Java 8+ 默认方法（有实现）
    default void land() {
        System.out.println("着陆");
    }

    // Java 8+ 静态方法
    static boolean canFly(Flyable f) {
        return f != null;
    }
}

public interface Swimmable {
    void swim();
}

// 类实现多个接口（弥补 Java 单继承）
public class Duck extends Animal implements Flyable, Swimmable {
    @Override public void fly()  { System.out.println("鸭子飞"); }
    @Override public void swim() { System.out.println("鸭子游"); }
}

@Override
public String toString() {              // 对象的字符串表示
    return "Student{name=" + name + ", age=" + age + "}";
}

@Override
public boolean equals(Object o) {        // 内容相等
    if (this == o) return true;
    if (!(o instanceof Student)) return false;
    Student s = (Student) o;
    return 18 == s.age && name.equals(s.name);
}

@Override
public int hashCode() {               // 哈希码（与 equals 配对）
    return Objects.hash(name, age);
}

// 枚举：一组固定常量的类型安全写法
public enum Color {
    RED, GREEN, BLUE;

    public String rgb() { return this.name(); }
}

// 使用
for (Color c : Color.values()) {
    System.out.println(c + " = " + c.rgb());
}

// Record（Java 16+）：不可变数据类，自动生成 equals/hashCode/toString
public record Point(int x, int y) { }
Point p = new Point(3, 4);   // p.toString() = "Point[x=3, y=4]"

// 自动装箱：int → Integer
Integer a = 10;             // 等价于 Integer.valueOf(10)

// 自动拆箱：Integer → int
int b = a;                  // 等价于 a.intValue()

// 字符串与整数互转
String s = String.valueOf(42);
int    n = Integer.parseInt("123");

// BigDecimal：金融计算（避免 double 精度问题）
BigDecimal money = new BigDecimal("0.1");
BigDecimal total = money.add(money).add(money);  // 0.3（精确）

// Math
Math.abs(-5);           // 5
Math.max(3, 7);       // 7
Math.sqrt(16);        // 4.0
Math.pow(2, 10);      // 1024.0
Math.random();        // [0, 1) 随机数

// Random
Random r = new Random();
int x = r.nextInt(100);  // [0, 100)
double y = r.nextDouble();

// System
System.out.println("标准输出");
System.err.println("标准错误");
System.out.printf("当前时间：%tT%n", System.currentTimeMillis());
// System.exit(0);   // 退出 JVM

try {
    // 可能出错的代码
    int result = 10 / 0;
} catch (ArithmeticException e) {        // 捕获特定异常
    System.err.println("数学错误：" + e.getMessage());
} catch (Exception e) {                  // 兜底：捕获更宽泛
    System.err.println("其它错误：" + e.getMessage());
} finally {
    // 无论是否出错都执行（资源清理）
    System.out.println("结束");
}

// 1) 自定义异常类
public class InsufficientFundsException extends Exception {
    private double shortage;
    public InsufficientFundsException(String msg, double shortage) {
        super(msg);
        this.shortage = shortage;
    }
    public double getShortage() { return shortage; }
}

// 2) 抛出异常（throw）与声明（throws）
public void withdraw(double amount) throws InsufficientFundsException {
    if (amount > balance)
        throw new InsufficientFundsException("余额不足", amount - balance);
    balance -= amount;
}

// ❌ 传统写法：手动关闭，容易遗漏
Scanner sc = null;
try {
    sc = new Scanner(new File("data.txt"));
    // ...
} finally {
    if (sc != null) sc.close();
}

// ✔ 现代写法：try-with-resources
try (Scanner sc = new Scanner(new File("data.txt"));
     FileWriter w = new FileWriter("out.txt")) {
    // sc 与 w 会在 try 结束时自动关闭
}

// 泛型类：T 是类型参数
public class Box<T> {
    private T value;
    public Box(T v) { this.value = v; }
    public T get()   { return value; }
}

Box<String>  bs = new Box<>("hi");    // T = String
Box<Integer> bi = new Box<>(42);    // T = Integer

// 泛型方法
public static <T> T first(List<T> list) {
    return list.get(0);
}

// 常见类型参数约定
// T = Type, E = Element, K = Key, V = Value, R = Return

List<Integer>    intList = Arrays.asList(1, 2, 3);
List<Number>    numList = Arrays.asList(1.5, 2.5);

// ? extends T：上界，能读不能写
public static double sum(List<? extends Number> list) {
    double s = 0;
    for (Number n : list) s += n.doubleValue();
    return s;
}

// ? super T：下界，能写不能读
public static void addInts(List<? super Integer> list) {
    list.add(42);   // 可以添加 Integer
}

import java.util.*;

List<String> list = new ArrayList<>();  // 父接口引用 + 子类实例（多态）
list.add("Alice");
list.add("Bob");
list.add("1", "Carol");           // 指定下标插入

String first = list.get(0);
list.set(0, "Alex");           // 修改
list.remove("Bob");          // 按值删除

System.out.println(list.size());   // 元素个数
System.out.println(list.contains("Alice"));

// 三种遍历
for (String s : list) { System.out.println(s); }
list.forEach(System.out::println);

Map<String, Integer> scores = new HashMap<>();

scores.put("Alice", 95);
scores.put("Bob", 87);
scores.put("Carol", 92);

Integer a = scores.get("Alice");       // 95，不存在则返回 null
Integer b = scores.getOrDefault("Dave", 0);

System.out.println(scores.containsKey("Alice"));
scores.remove("Bob");

// 三种遍历
scores.forEach((k, v) -> System.out.println(k + ": " + v));
for (Map.Entry<String, Integer> e : scores.entrySet()) {
    System.out.println(e.getKey() + "=" + e.getValue());
}

import java.nio.file.*;
import java.io.*;

// 读取整个文本文件（推荐用 NIO）
String content = Files.readString(Path.of("data.txt"), StandardCharsets.UTF_8);

// 写入
Files.writeString(Path.of("out.txt"), "Hello, Java!");

// 逐行读取（推荐用 try-with-resources）
try (BufferedReader br = Files.newBufferedReader(Path.of("data.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
}

import java.time.*;
import java.time.format.*;

LocalDate      today    = LocalDate.now();
LocalTime      now      = LocalTime.now();
LocalDateTime  datetime = LocalDateTime.now();
ZonedDateTime  zoned    = ZonedDateTime.now();

// 计算：加 7 天、减 3 个月
LocalDate nextWeek = today.plusDays(7);
LocalDate prevMonth = today.minusMonths(3);

// 格式化
DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String text = datetime.format(fmt);

// 解析
LocalDateTime parsed = LocalDateTime.parse("2024-03-15 10:30:00", fmt);

import java.util.regex.*;

Pattern p = Pattern.compile("\\d{3}-\\d{4}");     // 电话号码
Matcher m = p.matcher("电话：010-1234，021-5678");

while (m.find()) {
    System.out.println("找到：" + m.group());
}

// 校验邮箱
boolean ok = "a@b.com".matches("^[\\w.]+@[\\w.]+$");

// (参数) -> 表达式
Runnable r1 = () -> System.out.println("Hi");

Comparator<Integer> cmp = (a, b) -> a - b;

// 函数式接口（@FunctionalInterface）
// Consumer<T> 消费一个 T，无返回值
// Supplier<T> 生产一个 T，无参数
// Function<T,R> 接收 T，返回 R
// Predicate<T> 接收 T，返回 boolean

// 方法引用（Method Reference）
Function<String, Integer> len = String::length;
Consumer<String> printer = System.out::println;

List<String> names = Arrays.asList("Alice", "Bob", "Carol", "Alex");

// 找出以 A 开头、长度 > 4 的名字，按字母排序，去重
List<String> result = names.stream()
    .filter(s -> s.startsWith("A"))       // 过滤
    .filter(s -> s.length() > 4)        // 再过滤
    .sorted()                             // 排序
    .distinct()                           // 去重
    .limit(10)                            // 取前 10
    .collect(Collectors.toList());   // 收集

// 数值统计
IntStream range = IntStream.rangeClosed(1, 100);
long sum = range.sum();       // 5050
OptionalDouble avg = range.average();

Optional<String> opt = Optional.ofNullable(mayBeNull);

String result = opt
    .filter(s -> s.length() > 0)
    .map(String::toUpperCase)
    .orElse("默认值");

import java.lang.reflect.*;

Class<?> clazz = Student.class;

// 获取所有字段
for (Field f : clazz.getDeclaredFields()) {
    System.out.println("字段：" + f.getName());
}

// 动态创建对象
Student s = (Student) clazz.getDeclaredConstructor().newInstance();
s.study();

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
public @interface MyTest {
    String value() default "";
}

// 方式 1：继承 Thread
class MyThread extends Thread {
    @Override public void run() {
        System.out.println("线程运行：" + getName());
    }
}
new MyThread().start();

// 方式 2：实现 Runnable（推荐，可继续继承其他类）
class MyTask implements Runnable {
    public void run() {
        System.out.println("任务运行");
    }
}
new Thread(new MyTask()).start();

// 方式 3：Lambda（Java 8+）
new Thread(() -> System.out.println("Lambda")).start();

import java.util.concurrent.*;

ExecutorService pool = Executors.newFixedThreadPool(4);

for (int i = 0; i < 10; i++) {
    int taskId = i;
    pool.submit(() -> {
        System.out.println("任务 " + taskId);
    });
}

pool.shutdown();

class Counter {
    private int count = 0;

    // 同步方法
    public synchronized void inc() {
        count++;
    }

    // 同步块（更细粒度）
    public void inc2() {
        synchronized (this) {
            count++;
        }
    }
}

try (ServerSocket server = new ServerSocket(8080);
     Socket client = server.accept();                       // 阻塞等待客户端
     BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));
     PrintWriter out = new PrintWriter(client.getOutputStream(), true)) {

    String line;
    while ((line = in.readLine()) != null) {
        out.println("Echo: " + line);
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();

// 对象 → JSON 字符串
Student s = new Student("Alice", 20);
String json = mapper.writeValueAsString(s);   // {"name":"Alice","age":20}

// JSON 字符串 → 对象
Student s2 = mapper.readValue(json, Student.class);

// 1) 加载驱动（Java 6+ 可省）
Class.forName("com.mysql.cj.jdbc.Driver");

// 2) 建立连接
String url = "jdbc:mysql://localhost:3306/school?useSSL=false";
try (Connection conn = DriverManager.getConnection(url, "root", "pwd")) {

    // 3) 创建 PreparedStatement（推荐，防 SQL 注入）
    PreparedStatement ps = conn.prepareStatement(
        "SELECT * FROM students WHERE age > ?");
    ps.setInt(1, 18);

    // 4) 执行查询
    ResultSet rs = ps.executeQuery();
    while (rs.next()) {
        String name = rs.getString("name");
        int age = rs.getInt("age");
        System.out.printf("%s - %d%n", name, age);
    }

    // 5) 关闭资源（try-with-resources 自动）
}

import org.junit.jupiter.api.*;

class CalculatorTest {
    private Calculator calc;

    @BeforeEach
    void setUp() { calc = new Calculator(); }

    @Test
    void testAdd() {
        Assertions.assertEquals(5, calc.add(2, 3));
    }

    @Test
    void testDivideByZero() {
        Assertions.assertThrows(ArithmeticException.class,
            () -> calc.divide(1, 0));
    }
}

<!-- pom.xml：Maven 项目的核心配置 -->
<project>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example</groupId>        <--> 组织域名 -->
    <artifactId>demo</artifactId>          <--> 项目名 -->
    <version>1.0-SNAPSHOT</version>     <--> 版本 -->

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.10.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

class Node<T> {
    T data;
    Node<T> next;
    Node(T d) { data = d; }
}

public class MyLinkedList<T> {
    private Node<T> head;

    public void addFirst(T v) {
        Node<T> n = new Node<>(v);
        n.next = head;
        head = n;
    }

    public void print() {
        for (Node<T> p = head; p != null; p = p.next)
            System.out.print(p.data + " -> ");
        System.out.println("null");
    }
}

// 1) 读文本文件（NIO）
String text = Files.readString(Path.of("a.txt"), StandardCharsets.UTF_8);

// 2) 写文本
Files.writeString(Path.of("a.txt"), text);

// 3) 遍历 Map
Map.entrySet().forEach(e -> log(e.getKey(), e.getValue()));

// 4) 时间测量
long t0 = System.nanoTime();
// ...
long ms = (System.nanoTime() - t0) / 1_000_000;

// 5) List → Stream → Map
Map<Integer, String> m = list.stream()
    .collect(Collectors.toMap(Student::getId, Student::getName));