1
// 无 module-info.java 文件
2
// 应用程序作为一个整体运行，所有公共类都可访问。
3
// 依赖项通过类路径管理。

1
// module-info.java，用于名为 'com.example.myModule' 的模块
2
module com.example.myModule {
3
    // 导出 'services' 包，使其对其他模块公开
4
    exports com.example.myModule.services;
5
    // 声明对 'java.sql' 模块的依赖
6
    requires java.sql;
7
    // 可选：为反射打开一个包
8
    opens com.example.myModule.internal.data to com.example.anotherModule;
9
    // 声明此模块提供的服务
10
    provides com.example.myModule.spi.MyService with com.example.myModule.impl.MyServiceImpl;
11
    // 声明此模块使用的服务
12
    uses com.example.myModule.spi.AnotherService;
13
}

1
// 在 JShell 中：
2
jshell> System.out.println("Hello, JShell!");
3
Hello, JShell!
4
jshell> int x = 10;
5
x ==> 10

1
interface MyInterfaceJava8 {
2
    default void processData(String data) {
3
        // 通用验证逻辑
4
        if (data == null || data.isEmpty()) {
5
            throw new IllegalArgumentException("Data cannot be empty");
6
        }
7
        System.out.println("Processing: " + data);
8
    }
9

10
    default void analyzeData(String data) {
11
        // 通用验证逻辑（重复）
12
        if (data == null || data.isEmpty()) {
13
            throw new IllegalArgumentException("Data cannot be empty");
14
        }
15
        System.out.println("Analyzing: " + data);
2 collapsed lines
16
    }
17
}

1
interface MyInterfaceJava9 {
2
    default void processData(String data) {
3
        validate(data); // 调用私有辅助方法
4
        System.out.println("Processing: " + data);
5
    }
6

7
    default void analyzeData(String data) {
8
        validate(data); // 调用私有辅助方法
9
        System.out.println("Analyzing: " + data);
10
    }
11

12
    // 私有方法，仅在接口内部可访问
13
    private void validate(String data) {
14
        if (data == null || data.isEmpty()) {
15
            throw new IllegalArgumentException("Data cannot be empty");
3 collapsed lines
16
        }
17
    }
18
}

1
// 工厂方法创建集合
2
List<String> stringList = List.of("a", "b", "c", "d");
3
Set<String> stringSet = Set.of("a", "b", "c", "d");
4
Map<String, Integer> stringIntegerMap = Map.of("key1", 1, "key2", 2, "key3", 3);
5
Map<String, Integer> stringIntegerMap2 = Map.ofEntries(Map.entry("key1", 1), Map.entry("key2", 2));

1
Map<String, List<String>> userPreferences = new HashMap<String, List<String>>();
2
String message = "Hello, World!";
3
for (String item : items) { /*... */ }

1
var userPreferences = new HashMap<String, List<String>>(); // 类型推断为 Map<String, List<String>>
2
var message = "Hello, World!"; // 类型推断为 String
3
for (var item : items) { // 类型推断基于 'items' 集合的元素类型
4
    System.out.println(item);
5
}

1
// 使用 HttpURLConnection 的基本 GET 请求
2
import java.net.HttpURLConnection;
3
import java.net.URL;
4
import java.io.BufferedReader;
5
import java.io.InputStreamReader;
6
public class OldHttpClientExample {
7
public static void main(String args) throws Exception {
8
URL url = new URL("https://jsonplaceholder.typicode.com/todos/1");
9
HttpURLConnection con = (HttpURLConnection) url.openConnection();
10
con.setRequestMethod("GET");
11
    int responseCode = con.getResponseCode();
12
    System.out.println("Response Code: " + responseCode);
13

14
    if (responseCode == HttpURLConnection.HTTP_OK) { // 成功
15
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
12 collapsed lines
16
        String inputLine;
17
        StringBuffer content = new StringBuffer();
18
        while ((inputLine = in.readLine())!= null) {
19
            content.append(inputLine);
20
        }
21
        in.close();
22
        System.out.println("Response Body:\n" + content.toString());
23
    } else {
24
        System.out.println("GET request failed");
25
    }
26
}
27
}

1
// 使用 Java 11+ HttpClient 的 GET 请求（同步）
2
import java.net.URI;
3
import java.net.http.HttpClient;
4
import java.net.http.HttpRequest;
5
import java.net.http.HttpResponse;
6
import java.net.http.HttpResponse.BodyHandlers;
7
public class NewHttpClientExample {
8
public static void main(String args) throws Exception {
9
HttpClient client = HttpClient.newHttpClient();
10
HttpRequest request = HttpRequest.newBuilder()
11
.uri(URI.create("https://jsonplaceholder.typicode.com/todos/1"))
12
.GET() // 或.POST(HttpRequest.BodyPublishers.ofString("..."))
13
.build();
14
    HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
15

12 collapsed lines
16
    System.out.println("Response Code: " + response.statusCode());
17
    System.out.println("Response Body:\n" + response.body());
18

19
    // 异步示例
20
    /*
21
    client.sendAsync(request, BodyHandlers.ofString())
22
         .thenApply(HttpResponse::body)
23
         .thenAccept(System.out::println)
24
         .join(); // 等待完成
25
    */
26
}
27
}

1
String text = "  Hello World  \t\n";
2
System.out.println("'" + text.trim() + "'"); // 输出: 'Hello World' (仅移除 ASCII 空白字符)

1
String text = "  Hello World  \t\n\u2005"; // \u2005 是 Unicode "四分之一个空格"
2
System.out.println("'" + text.strip() + "'"); // 输出: 'Hello World' (移除 Unicode 空白字符)
3
System.out.println("'" + text.stripLeading() + "'"); // 输出: 'Hello World  \t\n\u2005'
4
System.out.println("'" + text.stripTrailing() + "'"); // 输出: '  Hello World'

1
// 下面两者是等价的
2
Consumer<String> consumer = (var i) -> System.out.println(i);
3
Consumer<String> consumer = (String i) -> System.out.println(i);

1
// 定义一个枚举类
2
public enum Day {
3
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
4
}
5
//老版本逻辑
6
Day day = Day.MONDAY;
7
int numLetters;
8

9
switch (day) {
10
    case MONDAY:
11
    case FRIDAY:
12
    case SUNDAY:
13
        numLetters = 6;
14
        break;
15
    case TUESDAY:
57 collapsed lines
16
        numLetters = 7;
17
        break;
18
    // 对于 switch 语句，default 不是必需的
19
    // 如果 day 是null，这里会抛出 NullPointerException
20
}
21

22
//新版本 switch 表达式的穷尽性检查 当 switch 表达式处理 enum 类型时，如果你覆盖了所有枚举常量，那么你不需要写 default 分支。
23
//switch表达式中枚举类中没有覆盖所有情况。会直接报错。当 switch 表达式处理 String、int 等类型时必须提供 default 分支
24

25
Day day = Day.TUESDAY;
26

27
int numLetters = switch (day) {
28
    case MONDAY, FRIDAY, SUNDAY -> 6;
29
    case TUESDAY                -> 7;
30
    case THURSDAY, SATURDAY     -> 8;
31
    case WEDNESDAY              -> 9;
32
    // 注意：这里没有 default 分支！
33
    // 因为编译器知道 Day 枚举的所有可能值都已被覆盖。
34
};
35
//switch作为语句情况下的更新变化
36
// 目标：在不同 case 中定义临时变量
37
switch (day) {
38
    case MONDAY:
39
        String mood = "Ugh, Mondays..."; // mood 的作用域会持续到 switch 结束
40
        System.out.println(mood);
41
        break;
42
    case TUESDAY:
43
        // String mood = "Slightly better."; // 编译错误！变量 mood 已在作用域中定义
44
        String differentMood = "Slightly better.";
45
        System.out.println(differentMood);
46
        break;
47
}
48
// 新代码 (独立作用域) 每个 -> 右侧的代码块都有自己的作用域，变量互不影响。不需要写break，避免漏写break，导致代码执行流程“贯穿”到下一个 case
49
switch (day) {
50
    case MONDAY -> {
51
        String mood = "Ugh, Mondays..."; // mood 只在这个代码块内有效
52
        System.out.println(mood);
53
    }
54
    case TUESDAY -> {
55
        String mood = "Slightly better."; // 这是一个新的、独立的作用域
56
        System.out.println(mood);
57
    }
58
    default -> System.out.println("Another day.");
59
}
60
//yield 关键字
61
String result = switch (day) {
62
            case "M", "W", "F" -> "MWF";
63
            case "T", "TH", "S" -> "TTS";
64
            default -> {
65
                if(day.isEmpty())
66
                    yield "Please insert a valid day.";
67
                else
68
                    yield "Looks like a Sunday.";
69
            }
70

71
        };
72
System.out.println(result);

1
String json = "{\n" +
2
              "  \"name\": \"John Doe\",\n" +
3
              "  \"age\": 30\n" +
4
              "}";
5
System.out.println(json);

1
String json = """
2
    {
3
      "name": "John Doe",
4
      "age": 30
5
    }
6
    """;
7
System.out.println(json);

1
public void processObject(Object obj) {
2
    if (obj instanceof String) {
3
        String s = (String) obj; // 显式类型转换
4
        System.out.println("Processing String: " + s.length());
5
    } else if (obj instanceof Integer) {
6
        Integer i = (Integer) obj; // 显式类型转换
7
        System.out.println("Processing Integer: " + (i * 2));
8
    }
9
}

1
public void processObject(Object obj) {
2
    if (obj instanceof String s) { // 模式变量 's'
3
        System.out.println("Processing String: " + s.length());
4
    } else if (obj instanceof Integer i) { // 模式变量 'i'
5
        System.out.println("Processing Integer: " + (i * 2));
6
    }
7
}

1
// Person.java (POJO) 或者使用lombok注解
2
public class Person {
3
    private final String name;
4
    private final int age;
5
public Person(String name, int age) {
6
    this.name = name;
7
    this.age = age;
8
}
9

10
public String getName() {
11
    return name;
12
}
13

14
public int getAge() {
15
    return age;
16 collapsed lines
16
}
17

18
@Override
19
public boolean equals(Object o) {
20
    if (this == o) return true;
21
    if (o == null || getClass()!= o.getClass()){
22
        return false;
23
    }
24
  Person person = (Person) o;
25
  return age == person.age && name.equals(person.name);
26
}
27
@Override
28
public int hashCode() {
29
    return Objects.hash(name, age);
30
}
31
}

1
// Person.java (Record)
2
public record Person(String name, int age) {
3
    // 可选：用于验证的自定义构造函数
4
    public Person {
5
        if (age < 0) {
6
            throw new IllegalArgumentException("Age cannot be negative");
7
        }
8
    }
9
    // 可选：自定义方法
10
    public String greet() {
11
        return "Hello, " + name;
12
    }
13
}

1
// Shape.java (传统)
2
public abstract class Shape {
3
    abstract double area();
4
}
5
// 任何类都可以扩展 Shape
6
public class Circle extends Shape { /*... / }
7
public class Rectangle extends Shape { /... / }
8
public class Triangle extends Shape { /... / }
9
public class Pentagon extends Shape { /... */ } // 可能出现意外扩展

1
// Shape.java (密封)
2
public sealed abstract class Shape permits Circle, Rectangle, Triangle {
3
    abstract double area();
4
}
5
// 允许的子类：
6
public final class Circle extends Shape { /*... / } // 必须是 final, sealed 或 non-sealed
7
public non-sealed class Rectangle extends Shape { /... / } // 可以进一步扩展
8
public sealed class Triangle extends Shape permits EquilateralTriangle { /... */ } // 自身也可以是密封的
9
// public class Pentagon extends Shape { /*... */ } // 编译错误：Pentagon 不是允许的子类

1
    public static void main(String[] args) throws InterruptedException {
2
        ExecutorService executor = Executors.newFixedThreadPool(10); // 受限于操作系统线程
3
        for (int i = 0; i < 100; i++) { // 模拟 100 个 I/O 密集型任务
4
            final int taskId = i;
5
            executor.submit(() -> {
6
                System.out.println("平台线程 " + Thread.currentThread().getName() + " 正在处理任务 " + taskId);
7
                try {
8
                    Thread.sleep(100); // 模拟阻塞 I/O
9
                } catch (InterruptedException e) {
10
                    Thread.currentThread().interrupt();
11
                }
12
                System.out.println("平台线程 " + Thread.currentThread().getName() + " 完成任务 " + taskId);
13
            });
14
        }
15
        executor.shutdown();
2 collapsed lines
16

17
    }

1
// 1、通过 Thread.ofVirtual() 创建
2
Runnable fn = () -> {
3
  // your code here
4
};
5

6
Thread thread = Thread.ofVirtual(fn).start();
7

8
// 2、通过 Thread.startVirtualThread() 、创建
9
Thread thread = Thread.startVirtualThread(() -> {
10
  // your code here
11
});
12

13
// 3、通过 Executors.newVirtualThreadPerTaskExecutor() 创建
14
var executorService = Executors.newVirtualThreadPerTaskExecutor();
15

68 collapsed lines
16
executorService.submit(() -> {
17
  // your code here
18
});
19

20
class CustomThread implements Runnable {
21
  @Override
22
  public void run() {
23
    System.out.println("CustomThread run");
24
  }
25
}
26

27
//4、通过 ThreadFactory 创建
28
CustomThread customThread = new CustomThread();
29
// 获取线程工厂类
30
ThreadFactory factory = Thread.ofVirtual().factory();
31
// 创建虚拟线程
32
Thread thread = factory.newThread(customThread);
33
// 启动线程
34
thread.start();
35

36

37
public class VirtualThreadTest {
38

39
    static List<Integer> list = new ArrayList<>();
40

41
    public static void main(String[] args) {
42
        // 开启线程 统计平台线程数
43
        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
44
        scheduledExecutorService.scheduleAtFixedRate(() -> {
45
            ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
46
            ThreadInfo[] threadInfo = threadBean.dumpAllThreads(false, false);
47
            updateMaxThreadNum(threadInfo.length);
48
        }, 10, 10, TimeUnit.MILLISECONDS);
49

50
        long start = System.currentTimeMillis();
51
        // 虚拟线程
52
        ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
53
        // 使用平台线程
54
//         ExecutorService executor =  Executors.newFixedThreadPool(200);
55
        for (int i = 0; i < 10000; i++) {
56
            executor.submit(() -> {
57
                try {
58
                    // 线程睡眠 0.5 s，模拟业务处理
59
                    TimeUnit.MILLISECONDS.sleep(500);
60
                } catch (InterruptedException ignored) {
61
                }
62
            });
63
        }
64
        executor.close();
65
        scheduledExecutorService.close();
66
        System.out.println("max：" + list.getFirst() + " platform thread/os thread");
67
        System.out.printf("totalMillis：%dms\n", System.currentTimeMillis() - start);
68

69

70
    }
71

72
    // 更新创建的平台最大线程数
73
    private static void updateMaxThreadNum(int num) {
74
        if (list.isEmpty()) {
75
            list.add(num);
76
        } else {
77
            Integer integer = list.getFirst();
78
            if (num > integer) {
79
                list.addFirst(num);
80
            }
81
        }
82
    }
83
}

1
// 定义一个数据载体 Point
2
record Point(int x, int y) {}
3

4
//老版本代码 (JDK 16 之前，或不使用记录模式)
5
public void processPointLegacy(Object obj) {
6
    // 目标：判断 obj 是否为 Point，并打印其坐标
7

8
    if (obj instanceof Point) {      // 步骤 1: 类型检查
9
        Point p = (Point) obj;       // 步骤 2: 强制类型转换
10

11
        int x = p.x();               // 步骤 3: 调用访问器方法获取 x
12
        int y = p.y();               // 步骤 4: 调用访问器方法获取 y
13

14
        System.out.println("这是一个点，坐标为: x=" + x + ", y=" + y);
15
    }
11 collapsed lines
16
}
17
// 更简洁的嵌套记录模式：新版本代码 (使用 JDK 21 的记录模式)
18
public void processPointNew(Object obj) {
19
    // 目标：判断 obj 是否为 Point，并打印其坐标
20

21
    // 类型检查、强制转换、数据解构，一步到位！
22
    if (obj instanceof Point(int x, int y)) {
23
        // 如果匹配成功，变量 x 和 y 会被自动创建并赋值
24
        System.out.println("这是一个点，坐标为: x=" + x + ", y=" + y);
25
    }
26
}

1
// 使用密封接口，告知编译器 Shape 只有这三种实现
2
sealed interface Shape {}
3
record Circle(double radius) implements Shape {}
4
record Rectangle(double width, double height) implements Shape {}
5
//不使用switch 模式匹配
6
public double getAreaLegacy(Shape shape) {
7
    // 处理 null 的前置判断
8
    if (shape == null) {
9
        return 0;
10
    }
11

12
    // 冗长且容易出错的 if-else if 链
13
    if (shape instanceof Circle) {
14
        Circle c = (Circle) shape; // 手动转换
15
        return Math.PI * c.radius() * c.radius();
46 collapsed lines
16
    } else if (shape instanceof Rectangle) {
17
        Rectangle r = (Rectangle) shape; // 手动转换
18
        return r.width() * r.height();
19
    } else {
20
        // 如果 Shape 接口未来新增了子类，这里需要手动修改，否则会出错
21
        throw new IllegalArgumentException("未知的形状");
22
    }
23
}
24
//(Java 21新版本代码 (使用模式匹配的 switch))
25
public double getAreaNew(Shape shape) {
26
    // 一体化的 switch 表达式，简洁、安全、可读性强
27
    return switch (shape) {
28
        // 1. 直接处理 null
29
        case null -> 0;
30

31
        // 2. 匹配 Circle 类型，并自动解构出 radius
32
        case Circle(double r) -> Math.PI * r * r;
33

34
        // 3. 匹配 Rectangle 类型，并使用 "when" 添加额外条件（守护模式）
35
        case Rectangle(double w, double h) when w == h -> {
36
            System.out.println("这是一个正方形！");
37
            yield w * h; // 使用 yield 返回块中的值
38
        }
39

40
        // 4. 匹配普通的 Rectangle
41
        case Rectangle(double w, double h) -> w * h;
42
    };
43
    // 注意：因为 Shape 是密封的，且我们处理了所有情况(Circle, Rectangle)，
44
    // 所以编译器知道我们已经覆盖了所有可能性，无需 default 分支。
45
}
46
//守护模式 (when 子句)
47
// 老方法
48
switch (obj) {
49
    case String s:
50
        if (s.length() > 5) { // 嵌套 if
51
            System.out.println("Long String");
52
        }
53
        break;
54
}
55

56
// 新方法：使用 when 将条件写在 case 级别
57
switch (obj) {
58
    case String s when s.length() > 5 -> System.out.println("Long String");
59
    case String s                      -> System.out.println("Short String");
60
    default -> {}
61
}

1
SequencedCollection<String> seqList = new ArrayList<>(List.of("A", "B", "C"));
2
System.out.println("First element: " + seqList.getFirst()); // "A"
3
System.out.println("Last element: " + seqList.getLast());   // "C"
4
System.out.println("Reversed: " + seqList.reversed()); // (返回一个视图)
5

6
SequencedSet<String> seqSet = new LinkedHashSet<>(Set.of("X", "Y", "Z"));
7
System.out.println("First element: " + seqSet.getFirst()); // "X"
8
System.out.println("Last element: " + seqSet.getLast());   // "Z"
9

10
SequencedMap<String, Integer> seqMap = new LinkedHashMap<>();
11
seqMap.put("one", 1);
12
seqMap.put("two", 2);
13
seqMap.put("three", 3);
14
System.out.println("First entry: " + seqMap.firstEntry()); // one=1
15
System.out.println("Last entry: " + seqMap.lastEntry());   // three=3
1 collapsed line
16
System.out.println("Reversed map: " + seqMap.reversed()); // {three=3, two=2, one=1}

1
// 启用分代ZGC
2
java -XX:+UseZGC -XX:+ZGenerational ...