Java教程 - Java 语言基础

# Ubuntu/Debian
sudo apt update
sudo apt install openjdk-11-jdk

# CentOS/RHEL
sudo yum install java-11-openjdk-devel

# Mac (使用 Homebrew)
brew install openjdk@11

# 验证
java -version
javac -version

/**
 * 文档注释：程序的入口类
 * @author YourName
 * @version 1.0
 * @since 2025-01-01
 */
public class HelloWorld {
    /**
     * 程序主入口方法
     * @param args 命令行参数数组
     */
    public static void main(String[] args) {
        // 打印输出到控制台
        System.out.println("Hello, World!");

        // 打印命令行参数
        if (args.length > 0) {
            System.out.println("命令行参数：");
            for (String arg : args) {
                System.out.println("  " + arg);
            }
        }
    }
}

# 编译源文件
javac HelloWorld.java

# 运行程序
java HelloWorld

# 带命令行参数运行
java HelloWorld arg1 arg2 arg3

# 查看字节码内容
javap -c HelloWorld

# 查看详细信息
javap -verbose HelloWorld

# 设置堆初始大小
-Xms512m

# 设置堆最大大小
-Xmx1024m

# 设置新生代大小
-Xmn256m

# 选择垃圾回收器
-XX:+UseG1GC

# 打印 GC 日志
-XX:+PrintGCDetails

/**
 * 文档注释：用于 javadoc 生成 API 文档
 * @author YourName
 * @version 1.0
 */
package com.example;          // 包声明（必须位于文件首行，注释之后）

import java.util.Scanner;     // 导入其他类

// 类声明：文件名必须为 HelloWorld.java
public class HelloWorld {
    // 静态变量（类变量）
    private static String message = "Hello";

    // 实例变量
    private int count;

    // 构造方法（默认无参构造器若不写，编译器自动提供；一旦写了其他构造器，默认无参消失）
    public HelloWorld() {
        count = 0;
    }

    // 程序入口 main 方法
    public static void main(String[] args) {
        // 标准输出
        System.out.println("Hello World");
        // 局部变量
        int x = 10;
        // 调用静态方法
        HelloWorld.show();
    }

    private static void show() {
        System.out.println(message);
    }
}

// 推荐风格：数据类型[] 数组名;
int[] arr1;          // 声明，栈中引用
arr1 = new int[5];   // 创建，堆中分配空间，默认值0

// 不推荐但合法的风格：int arr1[];

// 声明并创建
double[] arr2 = new double[10];

// 静态初始化（编译时确定元素）
String[] names = {"Alice", "Bob", "Charlie"};
// 等价于
String[] names2 = new String[]{"Alice", "Bob", "Charlie"};  // 匿名数组方式

// 规则二维数组：3行4列
int[][] matrix = new int[3][4];

// 访问与赋值
matrix[0][1] = 10;

// 不规则数组（锯齿数组）
int[][] jagged = new int[3][];
jagged[0] = new int[2];
jagged[1] = new int[3];
jagged[2] = new int[1];

// 静态初始化
int[][] arr = {
    {1, 2},
    {3, 4, 5},
    {6}
};

// 数组转 List（注意：返回的 List 不可增删，但可修改元素）
List<String> list = Arrays.asList("A","B","C");
// 若要完全可变，使用 new ArrayList<>(Arrays.asList(arr))
// 集合转数组
String[] arr = list.toArray(new String[0]);

Person p = new Person("Tom", 20);

class Parent {
    Parent(int x) { }
}

class Child extends Parent {
    Child() {
        super(10);  // 必须显式调用，因为父类没有无参构造
    }
}

public class BankAccount {
    private double balance;
    
    public double getBalance() {
        return balance;
    }
    
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    
    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            throw new IllegalArgumentException("余额不足");
        }
    }
}

class Animal {
    protected String name;
    public void speak() { System.out.println("动物叫"); }
}

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

Animal a = new Cat();
a.speak();   // 输出“喵喵”（多态）
System.out.println(a.name); // 访问 Animal 的 name，即使 Cat 也有同名变量

if (a instanceof Cat) {
    Cat c = (Cat) a;
    c.catchMouse();   // 调用子类特有方法
}

abstract class Shape {
    protected String color;
    
    public Shape(String color) { this.color = color; }
    
    public abstract double area();   // 抽象方法
    
    public void display() {          // 普通方法
        System.out.println("颜色：" + color);
    }
}

class Circle extends Shape {
    private double radius;
    
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

interface Vehicle {
    int MAX_SPEED = 120;   // 等价于 public static final int MAX_SPEED = 120;
    
    void start();           // 抽象方法，等价于 public abstract void start();
    
    default void stop() {   // 默认方法
        System.out.println("车辆停止");
        privateHelper();
    }
    
    static void honk() {    // 静态方法
        System.out.println("鸣笛");
    }
    
    private void privateHelper() {   // 私有方法
        System.out.println("内部辅助");
    }
}

class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("汽车启动");
    }
}

interface A { void a(); }
interface B { void b(); }
interface C extends A, B { void c(); }   // 多继承
class D implements C {
    public void a() {}
    public void b() {}
    public void c() {}
}

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
System.out.println(s1 == s2);   // true，同一常量池引用
System.out.println(s1 == s3);   // false，堆中不同对象
System.out.println(s1.equals(s3)); // true，内容相同

StringBuilder sb = new StringBuilder();        // 默认容量16
sb.append("Hello");                            // 追加
sb.append(" ").append("World");                // 链式调用
sb.insert(5, ",");                             // 在索引5插入","
sb.delete(5, 6);                               // 删除一个字符
sb.replace(0, 5, "Hi");                        // 替换 [0,5) 为 "Hi"
sb.reverse();                                  // 反转
String result = sb.toString();                 // 转为不可变 String
int len = sb.length();                         // 长度
sb.setLength(3);                               // 截断或补空字符

Integer a = 100;   // 使用缓存
Integer b = 100;
System.out.println(a == b);   // true

Integer c = 200;
Integer d = 200;
System.out.println(c == d);   // false，因为超出缓存范围，创建新对象

LocalDate today = LocalDate.now();
LocalDate specific = LocalDate.of(2025, 1, 1);   // 月份正常1-12
LocalDateTime dt = LocalDateTime.now();
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
String str = dt.format(dtf);
LocalDateTime parsed = LocalDateTime.parse("2025-01-01T12:00:00"); // 默认ISO格式

// 邮箱验证简单示例
String email = "user@example.com";
String regex = "^[\\w.-]+@[\\w.-]+\\.[a-zA-Z]{2,}$";
boolean matches = email.matches(regex);   // 便捷方法

// 使用 Pattern 和 Matcher 提取信息
Pattern p = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = p.matcher("日期：2025-01-15");
if (m.find()) {
    String year = m.group(1);   // 2025
    String month = m.group(2);  // 01
    String day = m.group(3);    // 15
}

try {
    // 可能抛出异常的代码
} catch (SpecificException e) {
    // 处理特定异常
    e.printStackTrace();  // 打印堆栈信息
} catch (AnotherException e) {
    // 可以有多个 catch 块，子类异常在前
} finally {
    // 无论是否发生异常，都会执行（除非 JVM 退出或 finally 块中抛异常）
    // 用于释放资源（关闭文件、数据库连接等）
}

// 自定义检查异常
class InsufficientFundsException extends Exception {
    public InsufficientFundsException() {
        super();
    }
    public InsufficientFundsException(String message) {
        super(message);
    }
}

// 使用
public void withdraw(double amount) throws InsufficientFundsException {
    if (amount > balance) {
        throw new InsufficientFundsException("余额不足，需要" + amount + "，当前余额" + balance);
    }
    balance -= amount;
}

// 错误：吞掉异常
try {
    // ...
} catch (Exception e) { 
    // 什么都没做 
}

// 正确：记录日志或重新抛出
catch (Exception e) {
    logger.error("发生错误", e);
    throw new MyAppException("处理失败", e);
}

int a = 10;
int b = a++ + ++a;
System.out.println(b);

class Parent {
    Parent(int x) { }
}
class Child extends Parent {
    Child() { }
}

Integer i1 = 100;
Integer i2 = 100;
Integer i3 = 200;
Integer i4 = 200;
System.out.println(i1 == i2);
System.out.println(i3 == i4);

class A {
    String s = "A";
    void print() { System.out.print(s); }
}
class B extends A {
    String s = "B";
    void print() { System.out.print(s); }
}
public class Test {
    public static void main(String[] args) {
        A obj = new B();
        System.out.print(obj.s);
        obj.print();
    }
}

class Parent {
    static { System.out.print("A"); }
    { System.out.print("B"); }
    public Parent() { System.out.print("C"); }
}
class Child extends Parent {
    static { System.out.print("D"); }
    { System.out.print("E"); }
    public Child() { System.out.print("F"); }
}
public class Test {
    public static void main(String[] args) {
        new Child();
    }
}

public class Test {
    public static void main(String[] args) {
        String s1 = "hello";
        String s2 = new String("hello");
        String s3 = "he" + "llo";
        System.out.println(s1 == s2);
        System.out.println(s1 == s3);
        System.out.println(s1.equals(s2));
    }
}

class Animal {
    public void speak() { System.out.println("动物叫"); }
}
class Dog extends Animal {
    public void speak() { System.out.println("汪汪"); }
    public void run() { System.out.println("狗跑"); }
}
public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.speak();
        // a.run();   // 如果取消注释，会编译错误吗？
    }
}

public class Test {
    public static int test() {
        int x = 1;
        try {
            x = 2;
            return x;
        } catch (Exception e) {
            x = 3;
            return x;
        } finally {
            x = 4;
        }
    }
    public static void main(String[] args) {
        System.out.println(test());
    }
}

public class Student {
    private String name;
    private int age;
    private double score;

    public Student() { }

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

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) {
        if (age < 0 || age > 150) {
            throw new IllegalArgumentException("年龄必须在0-150之间");
        }
        this.age = age;
    }

    public double getScore() { return score; }
    public void setScore(double score) {
        if (score < 0 || score > 100) {
            throw new IllegalArgumentException("成绩必须在0-100之间");
        }
        this.score = score;
    }

    @Override
    public String toString() {
        return String.format("姓名：%s，年龄：%d，成绩：%.1f", name, age, score);
    }

    public static void main(String[] args) {
        Student s = new Student("张三", 20, 88.5);
        System.out.println(s);
    }
}

class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException("存款金额必须大于0");
        }
        balance += amount;
    }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException("余额不足，当前余额：" + balance);
        }
        balance -= amount;
    }

    public double getBalance() { return balance; }
}

// 测试
public class TestBank {
    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        try {
            account.deposit(500);
            account.withdraw(2000);
        } catch (InsufficientFundsException e) {
            System.out.println(e.getMessage());
        }
    }
}

abstract class Shape {
    public abstract double area();
    public abstract double perimeter();
}

class Circle extends Shape {
    private double radius;
    public Circle(double r) { radius = r; }
    public double area() { return Math.PI * radius * radius; }
    public double perimeter() { return 2 * Math.PI * radius; }
}

class Rectangle extends Shape {
    private double width, height;
    public Rectangle(double w, double h) { width = w; height = h; }
    public double area() { return width * height; }
    public double perimeter() { return 2 * (width + height); }
}

public class TestShape {
    public static void main(String[] args) {
        Shape s1 = new Circle(5);
        Shape s2 = new Rectangle(4, 6);
        System.out.printf("圆面积：%.2f，周长：%.2f%n", s1.area(), s1.perimeter());
        System.out.printf("矩形面积：%.2f，周长：%.2f%n", s2.area(), s2.perimeter());
    }
}

List<String> list = new ArrayList<>();
list.add("A");
list.add(0, "B");           // 在索引 0 插入
list.set(1, "C");           // 替换索引 1 的元素
String s = list.get(0);     // 获取元素
list.remove(0);             // 按索引删除
list.remove("A");           // 按对象删除（首次出现）
int index = list.indexOf("C");  // 查找索引
boolean contains = list.contains("C");  // 是否包含

LinkedList<String> linked = new LinkedList<>();
linked.addFirst("First");   // 头部插入
linked.addLast("Last");     // 尾部插入
String first = linked.getFirst();
String last = linked.getLast();
linked.removeFirst();
linked.removeLast();

Set<String> set = new HashSet<>();
set.add("A");
set.add("A");   // 重复元素，不会添加
set.add(null);  // 允许 null
boolean isAdded = set.add("B");  // 返回是否添加成功

// 自然排序（元素实现 Comparable）
Set<Integer> treeSet = new TreeSet<>();
treeSet.add(5);
treeSet.add(1);
treeSet.add(3);
// 迭代输出：1, 3, 5

// 定制排序（提供 Comparator）
Set<String> customSet = new TreeSet<>((s1, s2) -> s2.compareTo(s1));  // 降序
customSet.add("B");
customSet.add("A");
customSet.add("C");
// 迭代输出：C, B, A

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("A", 3);   // 覆盖旧值，返回旧值 1
Integer value = map.get("A");      // 3
Integer defaultValue = map.getOrDefault("C", 0);  // 0
boolean containsKey = map.containsKey("A");   // true
boolean containsValue = map.containsValue(2); // true
map.remove("A");
map.clear();

// 遍历方式
// 1. 遍历键
for (String key : map.keySet()) {
    System.out.println(key + ": " + map.get(key));
}
// 2. 遍历值
for (Integer val : map.values()) {
    System.out.println(val);
}
// 3. 遍历键值对（推荐）
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
// 4. forEach + Lambda（JDK 8+）
map.forEach((k, v) -> System.out.println(k + ": " + v));

TreeMap<Integer, String> treeMap = new TreeMap<>();
treeMap.put(3, "C");
treeMap.put(1, "A");
treeMap.put(2, "B");
// 按键排序：1=A, 2=B, 3=C
Integer first = treeMap.firstKey();   // 1
Integer last = treeMap.lastKey();     // 3
Map.Entry<Integer, String> lower = treeMap.lowerEntry(2);  // 1=A

List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 2));

// 排序
Collections.sort(list);                    // 升序：[1, 2, 3]
Collections.sort(list, (a, b) -> b - a);   // 降序：[3, 2, 1]
Collections.reverse(list);                 // 反转

// 查找
int max = Collections.max(list);           // 最大值
int min = Collections.min(list);           // 最小值
int index = Collections.binarySearch(list, 2);  // 二分查找（需先排序）

// 打乱
Collections.shuffle(list);                 // 随机打乱

// 不可变集合
List<Integer> unmodifiable = Collections.unmodifiableList(list);
// unmodifiable.add(4);  // 抛出 UnsupportedOperationException

// 同步集合（线程安全，但性能较低，推荐使用并发包中的类）
List<Integer> synchronizedList = Collections.synchronizedList(list);

// 泛型类
public class Box<T> {
    private T content;

    public void set(T content) { this.content = content; }
    public T get() { return content; }
}

// 使用
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
String s = stringBox.get();  // 无需强制转换

Box<Integer> intBox = new Box<>();
intBox.set(100);
int i = intBox.get();

// 上界通配符：适合读取
public static double sum(List<? extends Number> list) {
    double total = 0;
    for (Number num : list) {
        total += num.doubleValue();  // 可以读取
    }
    // list.add(10);  // 编译错误，不能写入
    return total;
}

// 下界通配符：适合写入
public static void addNumbers(List<? super Integer> list) {
    list.add(10);   // 可以写入 Integer
    list.add(20);
    // Integer i = list.get(0);  // 编译错误，只能当作 Object
}

// 使用
List<Integer> integers = Arrays.asList(1, 2, 3);
List<Double> doubles = Arrays.asList(1.5, 2.5, 3.5);
System.out.println(sum(integers));   // 6.0
System.out.println(sum(doubles));    // 7.5

List<Number> numbers = new ArrayList<>();
addNumbers(numbers);

List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
System.out.println(strings.getClass() == integers.getClass());  // true，都是 ArrayList.class

// 语法：(参数列表) -> { 方法体 }
// 无参无返回值
Runnable r1 = () -> System.out.println("Hello");
Runnable r2 = () -> {
    System.out.println("Hello");
    System.out.println("World");
};

// 有参有返回值
Comparator<Integer> c1 = (a, b) -> a - b;
Comparator<Integer> c2 = (Integer a, Integer b) -> {
    return a.compareTo(b);
};

// 单参数可省略括号
Consumer<String> consumer = s -> System.out.println(s);

// 静态方法引用：ClassName::staticMethod
Function<String, Integer> parser = Integer::parseInt;
// 等价于：s -> Integer.parseInt(s)

// 实例方法引用：instance::instanceMethod
String str = "Hello";
Predicate<String> predicate = str::startsWith;
// 等价于：s -> str.startsWith(s)

// 特定类型的实例方法引用：ClassName::instanceMethod
Function<String, Integer> lengthGetter = String::length;
// 等价于：s -> s.length()

// 构造方法引用：ClassName::new
Supplier<List<String>> listSupplier = ArrayList::new;
// 等价于：() -> new ArrayList<>()

// 创建 Stream
// 1. 集合的 stream() 方法
List<String> list = Arrays.asList("A", "B", "C");
Stream<String> stream1 = list.stream();

// 2. 数组的 Arrays.stream()
String[] arr = {"A", "B", "C"};
Stream<String> stream2 = Arrays.stream(arr);

// 3. Stream.of()
Stream<String> stream3 = Stream.of("A", "B", "C");

// 4. 无限流
Stream<Double> randoms = Stream.generate(Math::random);  // 无限随机数流
Stream<Integer> naturals = Stream.iterate(0, n -> n + 1);  // 0, 1, 2, 3, ...

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// filter：过滤
Stream<Integer> filtered = numbers.stream().filter(n -> n % 2 == 0);  // 2, 4, 6, 8, 10

// map：映射
Stream<Integer> mapped = numbers.stream().map(n -> n * n);  // 1, 4, 9, 16, 25, ...

// flatMap：扁平化映射
List<List<Integer>> nested = Arrays.asList(
    Arrays.asList(1, 2),
    Arrays.asList(3, 4)
);
Stream<Integer> flattened = nested.stream().flatMap(List::stream);  // 1, 2, 3, 4

// distinct：去重
Stream<Integer> distincted = Stream.of(1, 2, 2, 3, 3, 3).distinct();  // 1, 2, 3

// sorted：排序
Stream<Integer> sorted = numbers.stream().sorted((a, b) -> b - a);  // 降序

// limit & skip：截取与跳过
Stream<Integer> limited = numbers.stream().limit(5);   // 前 5 个
Stream<Integer> skipped = numbers.stream().skip(5);    // 跳过前 5 个

// peek：调试（查看每个元素但不修改）
numbers.stream()
    .peek(n -> System.out.println("Processing: " + n))
    .filter(n -> n > 5)
    .forEach(System.out::println);

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

// forEach：遍历
numbers.stream().forEach(System.out::println);

// collect：收集到集合
List<Integer> list = numbers.stream().filter(n -> n > 2).collect(Collectors.toList());
Set<Integer> set = numbers.stream().collect(Collectors.toSet());
Map<Integer, String> map = numbers.stream().collect(Collectors.toMap(n -> n, n -> "Num" + n));

// reduce：归约
int sum = numbers.stream().reduce(0, (a, b) -> a + b);  // 求和：15
int product = numbers.stream().reduce(1, (a, b) -> a * b);  // 求积：120
Optional<Integer> max = numbers.stream().reduce(Integer::max);  // 最大值

// 统计
long count = numbers.stream().count();  // 元素个数
int sum2 = numbers.stream().mapToInt(Integer::intValue).sum();  // 求和
double avg = numbers.stream().mapToInt(Integer::intValue).average().orElse(0);  // 平均值
IntSummaryStatistics stats = numbers.stream().mapToInt(Integer::intValue).summaryStatistics();
System.out.println(stats.getMax());   // 5
System.out.println(stats.getMin());   // 1
System.out.println(stats.getSum());   // 15
System.out.println(stats.getAverage());  // 3.0

// 匹配
boolean anyMatch = numbers.stream().anyMatch(n -> n > 3);   // 是否存在 > 3 的元素
boolean allMatch = numbers.stream().allMatch(n -> n > 0);   // 是否所有元素 > 0
boolean noneMatch = numbers.stream().noneMatch(n -> n < 0); // 是否没有元素 < 0

// 查找
Optional<Integer> first = numbers.stream().findFirst();  // 第一个元素
Optional<Integer> any = numbers.stream().findAny();      // 任意一个元素（并行流中高效）

// 顺序流转并行流
Stream<Integer> parallel = numbers.stream().parallel();

// 直接创建并行流
Stream<Integer> parallel2 = numbers.parallelStream();

// 并行流注意事项：
// 1. 线程安全：避免共享可变状态
// 2. 顺序：forEach 不保证顺序，forEachOrdered 保证顺序
// 3. 性能：数据量大时才有优势，小数据量可能更慢

// 文件复制（字节流 + 缓冲）
try (FileInputStream fis = new FileInputStream("source.txt");
     FileOutputStream fos = new FileOutputStream("target.txt");
     BufferedInputStream bis = new BufferedInputStream(fis);
     BufferedOutputStream bos = new BufferedOutputStream(fos)) {
    byte[] buffer = new byte[1024];
    int len;
    while ((len = bis.read(buffer)) != -1) {
        bos.write(buffer, 0, len);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 读取文本文件（字符流 + 缓冲）
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
    String line;
    while ((line = br.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

// 写入文本文件
try (BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) {
    bw.write("Hello World");
    bw.newLine();  // 换行
    bw.write("Java IO");
} catch (IOException e) {
    e.printStackTrace();
}

ByteBuffer buffer = ByteBuffer.allocate(1024);  // 分配堆缓冲区
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);  // 直接缓冲区（堆外内存）

buffer.put((byte) 10);
buffer.put((byte) 20);
buffer.flip();  // 切换为读模式（position=0, limit=旧position）
byte b1 = buffer.get();
byte b2 = buffer.get();
buffer.clear();  // 清空（position=0, limit=capacity）

// 文件复制（NIO）
try (FileChannel inChannel = new FileInputStream("source.txt").getChannel();
     FileChannel outChannel = new FileOutputStream("target.txt").getChannel()) {
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    while (inChannel.read(buffer) != -1) {
        buffer.flip();
        outChannel.write(buffer);
        buffer.clear();
    }
} catch (IOException e) {
    e.printStackTrace();
}

// transferTo / transferFrom（零拷贝，高效）
try (FileChannel inChannel = new FileInputStream("source.txt").getChannel();
     FileChannel outChannel = new FileOutputStream("target.txt").getChannel()) {
    inChannel.transferTo(0, inChannel.size(), outChannel);
} catch (IOException e) {
    e.printStackTrace();
}

import java.nio.file.*;

// Path
Path path = Paths.get("dir", "subdir", "file.txt");  // 构建路径
Path absolute = path.toAbsolutePath();  // 转为绝对路径
Path normalized = path.normalize();     // 规范化（去除冗余的 . 和 ..）

// Files
boolean exists = Files.exists(path);
boolean isDirectory = Files.isDirectory(path);
long size = Files.size(path);

// 创建文件和目录
Files.createDirectories(Paths.get("dir/subdir"));
Files.createFile(Paths.get("dir/file.txt"));

// 复制、移动、删除
Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);
Files.move(source, target, StandardCopyOption.REPLACE_EXISTING);
Files.delete(path);
Files.deleteIfExists(path);

// 读取所有行（小文件）
List<String> lines = Files.readAllLines(path, StandardCharsets.UTF_8);
String content = Files.readString(path);  // JDK 11+

// 写入
Files.write(path, lines, StandardCharsets.UTF_8);
Files.writeString(path, "Hello World", StandardCharsets.UTF_8);  // JDK 11+

// 遍历目录
try (DirectoryStream<Path> stream = Files.newDirectoryStream(Paths.get("dir"))) {
    for (Path p : stream) {
        System.out.println(p.getFileName());
    }
}

// 递归遍历（深度优先）
Files.walk(Paths.get("dir")).forEach(System.out::println);

// 查找文件
Path found = Files.find(Paths.get("dir"), Integer.MAX_VALUE,
    (p, attr) -> p.getFileName().toString().endsWith(".txt"))
    .findFirst()
    .orElse(null);

// 1. 继承 Thread 类
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread running: " + Thread.currentThread().getName());
    }
}
MyThread t1 = new MyThread();
t1.start();

// 2. 实现 Runnable 接口（推荐，避免单继承限制）
class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable running");
    }
}
Thread t2 = new Thread(new MyRunnable());
t2.start();

// 3. Lambda 表达式（JDK 8+）
Thread t3 = new Thread(() -> System.out.println("Lambda thread"));
t3.start();

// 4. 实现 Callable 接口（有返回值，JDK 5+）
class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        Thread.sleep(1000);
        return 42;
    }
}
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(new MyCallable());
Integer result = future.get();  // 阻塞等待结果
executor.shutdown();

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public void decrement() {
        synchronized (this) {
            count--;
        }
    }

    public int getCount() {
        return count;
    }
}

import java.util.concurrent.locks.ReentrantLock;

class CounterWithLock {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();

    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();  // 必须在 finally 中释放锁
        }
    }

    public int getCount() {
        return count;
    }
}

class ProducerConsumer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 5;

    public synchronized void produce(int item) throws InterruptedException {
        while (queue.size() == capacity) {
            wait();  // 队列满，等待
        }
        queue.offer(item);
        System.out.println("Produced: " + item);
        notifyAll();  // 唤醒消费者
    }

    public synchronized int consume() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();  // 队列空，等待
        }
        int item = queue.poll();
        System.out.println("Consumed: " + item);
        notifyAll();  // 唤醒生产者
        return item;
    }
}

List<String> list = List.of("A", "B", "C");  // 不可变
Set<Integer> set = Set.of(1, 2, 3);
Map<String, Integer> map = Map.of("A", 1, "B", 2);

var list = new ArrayList<String>();  // 推断为 ArrayList<String>
var stream = list.stream();          // 推断为 Stream<String>

String text = "  Hello  ";
System.out.println(text.isBlank());   // false
System.out.println(text.strip());     // "Hello"
System.out.println("A\nB\nC".lines().count());  // 3
System.out.println("Hi".repeat(3));   // "HiHiHi"

// switch 表达式
int num = 2;
String result = switch (num) {
    case 1 -> "one";
    case 2 -> "two";
    default -> "unknown";
};

// Record（JDK 16 正式版）
record Point(int x, int y) { }
Point p = new Point(10, 20);
System.out.println(p.x());  // 10
System.out.println(p.y());  // 20

String json = """
    {
        "name": "Alice",
        "age": 30
    }
    """;

List<Integer> list = Stream.of(1, 2, 3).toList();  // 不可变 List

// Sealed Class（JDK 17 预览，JDK 21 正式）
sealed interface Shape permits Circle, Rectangle { }
final class Circle implements Shape { }
final class Rectangle implements Shape { }