1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// Chapter35VirtualThreads.java
public class Chapter35VirtualThreads {

    public static void main(String[] args) {
        // 使用 Thread.ofVirtual() 创建虚拟线程
        Thread virtualThread = Thread.ofVirtual()
                .name("my-virtual-thread")
                .start(() -> {
                    // 这是一个虚拟线程
                    System.out.println("我是虚拟线程，我运行了！");
                    System.out.println("我的线程名: " + Thread.currentThread());
                });

        // 等待虚拟线程结束
        try {
            virtualThread.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.err.println("线程被中断了");
        }

        System.out.println("主线程也完成了");
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// Chapter35VirtualThreadsMillion.java
import java.time.Duration;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Chapter35VirtualThreadsMillion {

    public static void main(String[] args) throws InterruptedException {
        int count = 10000;  // 创建 10000 个虚拟线程
        System.out.println("开始创建 " + count + " 个虚拟线程...");

        long start = System.currentTimeMillis();

        try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // 为每个任务创建一个虚拟线程
            for (int i = 0; i < count; i++) {
                final int taskId = i;
                executor.submit(() -> {
                    // 模拟 I/O 操作：sleep 模拟网络请求
                    try {
                        Thread.sleep(Duration.ofSeconds(1));
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    }
                    return "任务 " + taskId + " 完成";
                });
            }
            // 所有任务提交完毕，executor 关闭后自动等待完成
        } // executor 关闭后，所有虚拟线程任务完成

        long duration = System.currentTimeMillis() - start;
        System.out.println(count + " 个任务全部完成，耗时: " + duration + "ms");
        // 如果用平台线程，10000 个线程同时运行几乎不可能；
        // 虚拟线程则可以轻松应对，因为它们共享少量载体线程
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// Chapter35StringAlternatives.java
public class Chapter35StringAlternatives {

    public static void main(String[] args) {
        String name = "阿柴";
        int age = 18;
        double score = 98.765;

        // 1) 最常用：String.format / String::formatted
        String s1 = String.format("姓名: %s，年龄: %d，成绩: %.2f", name, age, score);
        String s2 = "姓名: %s，年龄: %d".formatted(name, age);
        System.out.println(s1);
        System.out.println(s2);

        // 2) 多行模板：文本块 + formatted，最舒服的写法
        String s3 = """
                姓名: %s
                年龄: %d
                两年后: %d
                """.formatted(name, age, age + 2);
        System.out.println(s3);

        // 3) 需要位置参数或本地化时，用 MessageFormat
        String s4 = java.text.MessageFormat.format("你好，{0}！你今年 {1} 岁。", name, age);
        System.out.println(s4);
    }
}

1
2
3
4
5
6
7

姓名: 阿柴，年龄: 18，成绩: 98.77
姓名: 阿柴，年龄: 18
姓名: 阿柴
年龄: 18
两年后: 20

你好，阿柴！你今年 18 岁。

1
2
3
4
5
6

// 传统 switch：只能匹配常量
switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> System.out.println("6点");
    case TUESDAY -> System.out.println("7点");
    // ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

// Chapter35PatternMatchingSwitch.java
public class Chapter35PatternMatchingSwitch {

    public static void main(String[] args) {
        Object[] values = {
                42,
                3.14159,
                "Hello",
                true,
                null,
                'X',
                new int[]{1, 2, 3}
        };

        for (Object value : values) {
            String result = switch (value) {
                // null 需要单独处理（否则 NPE）
                case null -> "空值（null）";
                // 匹配 Integer 类型并绑定为 i
                case Integer i -> "整数: " + i + "（绝对值：" + Math.abs(i) + "）";
                // 匹配 Double 类型，范围判断
                case Double d when d > 0 -> "正小数: " + d;
                case Double d -> "非正小数: " + d;
                // 匹配字符串
                case String s -> "字符串: \"" + s + "\"（长度：" + s.length() + "）";
                // 匹配布尔值
                case Boolean b -> "布尔值: " + b;
                // 匹配字符
                case Character c -> "字符: " + c;
                // 默认分支
                default -> "未知类型: " + value.getClass().getName();
            };
            System.out.println(result);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// Chapter35RecordPatternSwitch.java
public class Chapter35RecordPatternSwitch {

    // 定义一个 Record
    record Point(int x, int y) {}

    public static void main(String[] args) {
        Object[] shapes = {
                new Point(0, 0),
                new Point(3, 4),
                "circle",
                new int[]{1, 2},
                new Point(-1, -1)
        };

        for (Object shape : shapes) {
            String result = switch (shape) {
                // 匹配 Record 并同时解构（x, y）
                case Point(int x, int y) when x == 0 && y == 0 -> "原点 " + shape;
                case Point(int x, int y) when x == y -> "对角线点（x=y=" + x + "）";
                case Point(int x, int y) -> "普通点: (" + x + ", " + y + ")";
                case String s -> "字符串: " + s;
                case null -> "空对象";
                default -> "其他图形";
            };
            System.out.println(result);
        }
    }
}

1
2
3
4
5
6
7
8
9

// 传统 POJO： getters、setters、equals、hashCode、toString... 一大堆模板代码
public class Person {
    private final String name;
    private final int age;
    public Person(String name, int age) { this.name = name; this.age = age; }
    public String getName() { return name; }
    public int getAge() { return age; }
    // equals, hashCode, toString... 省略 50 行
}

1
2

// 一行搞定！编译器自动生成：构造函数、getters、equals、hashCode、toString
public record Person(String name, int age) {}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

// Chapter35RecordPatterns.java
public class Chapter35RecordPatterns {

    // 定义几个 Record
    record Person(String name, int age) {}
    record Address(String city, String district) {}
    record Employee(Person person, Address address, double salary) {}

    public static void main(String[] args) {
        Employee emp = new Employee(
                new Person("阿柴", 18),
                new Address("杭州", "西湖区"),
                25000.50
        );

        // 场景1：在 instanceof 中使用 Record Pattern（Java 16+）
        if (emp.person() instanceof Person(String n, int a)) {
            System.out.println("instanceof 解构: " + n + "，今年 " + a + " 岁");
        }

        // 场景2：嵌套 Record Pattern（Java 21+）
        if (emp instanceof Employee(Person(String name, int age), Address(String city, _), double salary)) {
            System.out.println("嵌套解构:");
            System.out.println("  姓名: " + name);
            System.out.println("  年龄: " + age);
            System.out.println("  城市: " + city);
            System.out.println("  薪资: " + salary);
        }

        // 场景3：在 for 循环中使用 Record Pattern（需借助 instanceof）
        Person[] people = {
                new Person("小明", 20),
                new Person("小红", 22),
                new Person("小张", 19)
        };
        System.out.println("\n遍历解构：");
        for (Person p : people) {
            if (p instanceof Person(String n, int a)) {
                System.out.println("  " + n + " -> " + a + "岁");
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Chapter35ScopedValues.java
public class Chapter35ScopedValues {

    // 定义一个 Scoped Value（类似于 ThreadLocal，但更安全）
    private static final ScopedValue<String> CURRENT_USER = ScopedValue.newInstance();

    public static void main(String[] args) throws Exception {
        System.out.println("主线程直接读取（未设置）: " + CURRENT_USER.orElse("未登录"));

        // 在作用域内设置和读取 Scoped Value
        ScopedValue.where(CURRENT_USER, "阿柴").run(() -> {
            System.out.println("作用域内读取: " + CURRENT_USER.get());
            doSomething(); // 嵌套调用也能读取到
        });

        System.out.println("作用域外读取: " + CURRENT_USER.orElse("未登录"));

        // Scoped Value 天然支持虚拟线程
        Thread.ofVirtual().start(() -> {
            ScopedValue.where(CURRENT_USER, "虚拟线程用户").run(() -> {
                System.out.println("虚拟线程中: " + CURRENT_USER.get());
            });
        }).join();
    }

    // 嵌套方法也能读到 Scoped Value（跨方法传递无需参数）
    private static void doSomething() {
        System.out.println("  [嵌套] 读取到用户: " + CURRENT_USER.get());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

// Chapter35ForeignMemory.java
import java.lang.foreign.Arena;
import java.lang.foreign.FunctionDescriptor;
import java.lang.foreign.Linker;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.SymbolLookup;
import java.lang.foreign.ValueLayout;
import java.lang.invoke.MethodHandle;
import java.nio.charset.StandardCharsets;

public class Chapter35ForeignMemory {

    public static void main(String[] args) throws Throwable {
        Linker linker = Linker.nativeLinker();

        // 获取 C 运行时的符号查找器：
        // defaultLookup() 会查找当前平台默认的 C 库（macOS/Linux 上是 libc，Windows 上是 C 运行时）。
        // 若要从任意动态库查找，可改用 SymbolLookup.libraryLookup("libc.dylib", Arena.global())。
        SymbolLookup stdlib = linker.defaultLookup();

        // 找到 strlen 函数的地址
        MemorySegment strlenAddr = stdlib.find("strlen")
                .orElseThrow(() -> new RuntimeException("找不到 strlen 函数"));

        // 描述 C 函数签名：size_t strlen(const char* str)
        // size_t 是平台相关的无符号整数，64 位平台上用 JAVA_LONG 表示；指针用 ADDRESS 表示。
        FunctionDescriptor strlenDescriptor = FunctionDescriptor.of(
                ValueLayout.JAVA_LONG,   // 返回值 size_t
                ValueLayout.ADDRESS      // 参数 const char*
        );

        // 创建方法句柄（downcall handle 负责把 Java 调用翻译成 native 调用）
        MethodHandle strlenHandle = linker.downcallHandle(strlenAddr, strlenDescriptor);

        String testString = "你好，Java FFM!";
        try (Arena arena = Arena.ofConfined()) {
            // 将 Java 字符串按 UTF-8 复制到 native 内存（末尾自动补 '\0'）
            MemorySegment nativeString = arena.allocateFrom(testString, StandardCharsets.UTF_8);

            // 调用 strlen 获取字节长度
            long length = (long) strlenHandle.invoke(nativeString);
            System.out.println("C strlen 结果: " + length);
            System.out.println("Java 字符串字节数: " + testString.getBytes(StandardCharsets.UTF_8).length);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

// Chapter35MemoryManagement.java
import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.MemoryLayout;
import java.lang.foreign.ValueLayout;

public class Chapter35MemoryManagement {

    public static void main(String[] args) {
        // Arena 有三种工厂方法：
        // 1. Arena.ofConfined() - 只能被创建它的线程使用，关闭后释放
        // 2. Arena.ofShared()   - 可被多线程共享，所有使用者退出后释放
        // 3. Arena.ofAuto()     - 交给 GC 自动管理，无需手动关闭

        try (Arena arena = Arena.ofConfined()) {
            // 分配 100 字节
            MemorySegment segment = arena.allocate(100);
            System.out.println("分配的内存段: " + segment);
            System.out.println("大小: " + segment.byteSize());

            // 分配并写入一个 int 数组（allocateFrom 会把 Java 值直接拷进 native 内存）
            MemorySegment intArray = arena.allocateFrom(ValueLayout.JAVA_INT, 1, 2, 3, 4, 5);
            System.out.println("int 数组长度: " + intArray.byteSize() / 4); // 每个 int 4 字节

            // 定义结构体内存布局（模拟 C 的 struct { int age; long address; }）
            // 注意 C 的对齐规则：int 后面需要 4 字节填充，long 才能 8 字节对齐，
            // 因此必须显式插入 paddingLayout(4)，否则 structLayout 会直接抛异常。
            MemoryLayout personLayout = MemoryLayout.structLayout(
                    ValueLayout.JAVA_INT.withName("age"),
                    MemoryLayout.paddingLayout(4),
                    ValueLayout.JAVA_LONG.withName("address")
            );
            MemorySegment person = arena.allocate(personLayout);
            System.out.println("person 结构体布局: " + personLayout);
            // 按字段偏移量读写结构体成员
            person.set(ValueLayout.JAVA_INT,
                    personLayout.byteOffset(MemoryLayout.PathElement.groupElement("age")), 18);
            person.set(ValueLayout.JAVA_LONG,
                    personLayout.byteOffset(MemoryLayout.PathElement.groupElement("address")), 1000L);
            int age = person.get(ValueLayout.JAVA_INT,
                    personLayout.byteOffset(MemoryLayout.PathElement.groupElement("age")));
            long address = person.get(ValueLayout.JAVA_LONG,
                    personLayout.byteOffset(MemoryLayout.PathElement.groupElement("address")));
            System.out.println("age = " + age + ", address = " + address);
        } // Arena 关闭后，所有分配的内存自动释放 —— 无需手动 free！
    }
}

1
2
3
4
5
6

// 想要：取前5个、相邻两两配对、扁平化
List<String> result = list.stream()
    .takeWhile(...)
    .dropWhile(...)
    // ... 没有直接的"相邻配对"操作
    // 必须自己写 collector 或者用第三方库

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// Chapter35StreamGatherers.java
import java.util.List;
import java.util.stream.Gatherers;

public class Chapter35StreamGatherers {

    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // 1. windowFixed(n) - 固定大小窗口
        System.out.println("=== windowFixed(3) ===");
        numbers.stream()
                .gather(Gatherers.windowFixed(3))
                .forEach(window -> System.out.println(window));
        // 输出: [1,2,3], [4,5,6], [7,8,9], [10]

        // 2. windowSliding(n) - 滑动窗口
        System.out.println("\n=== windowSliding(3) ===");
        numbers.stream()
                .gather(Gatherers.windowSliding(3))
                .forEach(window -> System.out.println(window));
        // 输出: [1,2,3], [2,3,4], [3,4,5], ...

        // 3. fold(initialSupplier, folder) - 折叠成单个结果（注意第一个参数是"初始值工厂"）
        System.out.println("\n=== fold - 累加 ===");
        List<Integer> summed = numbers.stream()
                .gather(Gatherers.fold(() -> 0, Integer::sum))
                .toList();
        System.out.println("累加结果: " + summed); // [55]

        // 4. scan(initialSupplier, scanner) - 前缀累积（类似 Haskell 的 scanl）
        System.out.println("\n=== scan - 前缀累积 ===");
        numbers.stream()
                .limit(5)
                .gather(Gatherers.scan(() -> 0, Integer::sum))
                .forEach(n -> System.out.print(n + " ")); // 1 3 6 10 15

        // 5. mapConcurrent - 并发映射（正式功能，用虚拟线程并发执行映射函数）
        System.out.println("\n\n=== mapConcurrent(3) ===");
        List<String> names = List.of("Alice", "Bob", "Charlie", "David");
        names.stream()
                .gather(Gatherers.mapConcurrent(3, String::toUpperCase))
                .forEach(name -> System.out.println(name));
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

// Chapter35CustomGatherer.java
import java.util.ArrayList;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.Gatherer;
import java.util.stream.Gatherer.Integrator;

public class Chapter35CustomGatherer {

    // 自定义 Gatherer：去除连续重复元素
    // 例如: [1, 1, 2, 2, 2, 3, 1, 1] -> [1, 2, 3, 1]
    public static <T> Gatherer<T, ?, T> distinctConsecutive() {
        return Gatherer.ofSequential(
                // 状态初始化器：流开始时创建一份状态，这里用一个列表记录"已经输出过的最后一个元素"
                (Supplier<List<T>>) ArrayList::new,
                // 整合器：每来一个元素调用一次，需要时把结果 push 给下游
                (Integrator<List<T>, T, T>) (state, element, downstream) -> {
                    if (state.isEmpty() || !state.get(state.size() - 1).equals(element)) {
                        state.add(element);
                        return downstream.push(element); // 输出这个元素
                    }
                    return true; // 与上一个相同，跳过，继续处理下一个
                });
    }

    public static void main(String[] args) {
        List<Integer> data = List.of(1, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 5, 5, 5);
        System.out.println("去重相邻: " + data.stream()
                .gather(distinctConsecutive())
                .toList());
        // 输出: [1, 2, 3, 4, 5]
    }
}

1
2
3
4
5
6
7
8

// 传统写法：线程的启动和生命周期管理是分离的
void process() {
    ExecutorService executor = Executors.newFixedThreadPool(4);
    Future<?> f1 = executor.submit(task1);  // 提交后就没有结构化保证
    Future<?> f2 = executor.submit(task2);
    // 如果这里抛异常，executor 还没 shutdown，后台线程还在跑！
    executor.shutdown();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// Chapter35StructuredConcurrency.java
import java.util.concurrent.StructuredTaskScope;
import java.util.concurrent.StructuredTaskScope.Joiner;

public class Chapter35StructuredConcurrency {

    public static void main(String[] args) throws Exception {
        System.out.println("=== 结构化并发示例 ===\n");
        basicExample();
        failureExample();
        anySuccessExample();
    }

    // 示例1：基础使用
    static void basicExample() throws InterruptedException {
        System.out.println("示例1: 基础结构化并发");
        // open() 使用默认的 Joiner（等待所有子任务成功完成）
        try (var scope = StructuredTaskScope.open()) {
            // fork 两个子任务
            var future1 = scope.fork(() -> {
                Thread.sleep(100);
                return "任务1完成";
            });
            var future2 = scope.fork(() -> {
                Thread.sleep(200);
                return "任务2完成";
            });

            // 等待所有 fork 的任务完成（blocking）
            scope.join();

            // 获取结果（任务已保证完成）
            System.out.println("  " + future1.get());
            System.out.println("  " + future2.get());
        }
        System.out.println("  作用域结束，所有子任务自动收尾\n");
    }

    // 示例2：任一失败即取消其余任务
    static void failureExample() throws Exception {
        System.out.println("示例2: 任一失败，全部取消");
        // Joiner.awaitAllSuccessfulOrThrow()：只要有一个子任务失败，
        // 就取消其他仍在运行的任务，join() 时抛出异常。
        try (var scope = StructuredTaskScope.open(Joiner.<String>awaitAllSuccessfulOrThrow())) {
            scope.fork(() -> {
                Thread.sleep(50);
                return "快速任务";
            });
            scope.fork(() -> {
                throw new RuntimeException("模拟任务失败");
            });

            scope.join(); // 有失败则在这里抛出
            System.out.println("  全部成功！");
        } catch (Exception e) {
            System.out.println("  捕获到异常: " + e.getCause().getMessage());
        }
        System.out.println();
    }

    // 示例3：取第一个成功的结果（竞速）
    static void anySuccessExample() throws Exception {
        System.out.println("示例3: 取第一个成功的结果（竞速谁最快）");
        // Joiner.anySuccessfulResultOrThrow()：谁先成功就用谁的结果，
        // join() 直接返回该结果，其余任务自动取消。
        try (var scope = StructuredTaskScope.open(Joiner.<String>anySuccessfulResultOrThrow())) {
            scope.fork(() -> {
                Thread.sleep(300);
                return "服务器A（慢）";
            });
            scope.fork(() -> {
                Thread.sleep(100);
                return "服务器B（快）";
            });
            scope.fork(() -> {
                Thread.sleep(200);
                return "服务器C（中）";
            });

            String winner = scope.join();
            System.out.println("  竞速冠军: " + winner);
        } catch (Exception e) {
            System.out.println("  全部失败: " + e);
        }
    }
}

1
2

javac --release 25 --enable-preview Chapter35StructuredConcurrency.java
java --enable-preview Chapter35StructuredConcurrency

1
2
3
4
5

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

1
2
3
4
5

// HelloJava.java —— 不需要 class 声明，不需要 public，不需要 static
void main() {
    System.out.println("Java 也能写脚本了！");
    System.out.println("Hello from Java " + System.getProperty("java.version"));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// Chapter35ImplicitClass.java
// 不需要 class 关键字！编译器会隐式创建一个同文件名的类
// 不需要 public 修饰符
// 不需要 static 修饰 main 方法

// 实例字段
String name = "阿柴";

// 实例 main 方法（注意：不是 static）
void main() {
    System.out.println("你好，名字: " + name);
    doStuff();
    System.out.println("计算 1+2 = " + add(1, 2));
}

// 其他实例方法
void doStuff() {
    System.out.println("这是隐式类的实例方法");
}

int add(int a, int b) {
    return a + b;
}

// 也可以有静态方法
static void staticMethod() {
    System.out.println("静态方法也可以");
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// Chapter35ImplicitWithVT.java
// 直接运行：java Chapter35ImplicitWithVT.java（Java 25 起无需 --enable-preview）

void main() {
    System.out.println("隐式类 + 虚拟线程演示");

    Thread.ofVirtual().start(() -> {
        System.out.println("我是隐式类中的虚拟线程！");
    });

    System.out.println("主线程继续执行...");
    try {
        Thread.sleep(100);
    } catch (InterruptedException ignored) {}
}