Java8

1. Lambda表达式‌

‌理解‌：简化匿名内部类，允许将函数作为方法参数传递。
‌用法‌：(参数) -> {表达式或代码块}
‌示例‌：

// 传统匿名内部类
Runnable r1 = new Runnable() {@Overridepublic void run() {System.out.println("Hello");}
};// Lambda简化
Runnable r2 = () -> System.out.println("Hello");

‌2. Stream API‌

‌理解‌：函数式数据流操作（过滤、映射、聚合等），支持链式调用。
‌用法‌：通过stream()创建流，结合filter/map/collect等方法。
‌示例‌：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
List<String> filtered = names.stream().filter(name -> name.startsWith("A")) // 过滤.map(String::toUpperCase)             // 映射.collect(Collectors.toList());        // 收集为List

‌3. 方法引用‌

‌理解‌：进一步简化Lambda，直接引用已有方法。
‌用法‌：类名::方法名 或 对象::方法名。

• 静态方法引用：ClassName::staticMethod
• 实例方法引用：instance::method 或 ClassName::instanceMethod（特殊形式）
• 构造方法引用：ClassName::new

‌示例‌：

// Lambda写法
names.forEach(name -> System.out.println(name));// 方法引用简化
names.forEach(System.out::println);// 1. 静态方法引用
Function<String, Integer> f1 = Integer::parseInt;// 2. 绑定实例方法引用
String str = "test";
Supplier<Integer> f2 = str::length;// 3. 未绑定实例方法引用
Function<String, Integer> f3 = String::length;// 4. 构造方法引用
Supplier<List<String>> f4 = ArrayList::new;

‌4. 默认方法（Default Methods）‌

‌理解‌：接口中可以定义默认实现，避免破坏现有实现类。
‌用法‌：default关键字修饰接口方法。
‌示例‌：

interface Vehicle {default void start() {System.out.println("Vehicle started");}
}class Car implements Vehicle {} // 无需重写start()

‌5. Optional类‌

‌理解‌：包装可能为null的值，避免空指针异常。
‌用法‌：Optional.ofNullable()结合orElse()/ifPresent()。

原理：

   

1. ‌封装与空安全‌

• 本质是泛型不可变容器类（final class Optional<T>）
• 通过私有构造器强制要求非空值必须显式包装
• 空值统一用private static final Optional<?> EMPTY表示

1. ‌核心实现机制‌

• 值存储：private final T value字段存储实际对象
• 空检查：所有方法内部首先检查value == null
• 链式调用：方法返回新Optional实例保证不可变性

1. ‌关键方法实现‌

• of()：直接赋值前进行非空校验（Objects.requireNonNull）
• ofNullable()：允许传入null值，内部转为EMPTY实例
• map()/flatMap()：通过函数式接口实现惰性求值
• orElse()：通过Supplier延迟备选值计算

1. ‌线程安全设计‌

• 所有字段声明为final（包括存储的value）
• 不提供修改内部状态的方法
• 每次操作返回新实例（类似String的不可变性）

1. ‌性能优化点‌

• EMPTY单例模式减少对象创建
• 静态工厂方法避免重复校验
• 流式API避免中间对象分配

‌示例‌：

Optional<String> name = Optional.ofNullable(getName());
String result = name.orElse("Default"); // 如果为null返回默认值
name.ifPresent(System.out::println);    // 非空时执行

‌6. 新的日期时间API（java.time）‌

‌理解‌：替代java.util.Date，线程安全且易用。
‌核心类‌：LocalDate、LocalTime、ZonedDateTime、LocalDateTime。
‌示例‌：

LocalDate today = LocalDate.now();
LocalDate nextWeek = today.plusDays(7);
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formatted = today.format(formatter);

‌7. 函数式接口（@FunctionalInterface）‌

‌理解‌：只有一个抽象方法的接口，支持Lambda。

Java 8中主要的函数式接口可分为四大类，位于java.util.function包中：

一、核心函数式接口

1. ‌Function<T,R>‌

   • 方法：R apply(T t)

   • 用途：接受一个输入返回一个结果

2. ‌Consumer<T>‌

   • 方法：void accept(T t)

   • 用途：消费一个输入不返回结果

3. ‌Supplier<T>‌

   • 方法：T get()

   • 用途：无输入返回一个值

4. ‌Predicate<T>‌

   • 方法：boolean test(T t)

   • 用途：输入判断返回布尔值

二、原始类型特化接口

1. ‌IntFunction<R>‌ / ‌DoubleFunction<R>‌

   • 专为基本类型优化的Function

2. ‌ToIntFunction<T>‌ / ‌ToDoubleFunction<T>‌

   • 返回基本类型的Function

3. ‌IntConsumer‌ / ‌DoubleConsumer‌

   • 基本类型的Consumer

三、二元操作接口

1. ‌BiFunction<T,U,R>‌

   • 方法：R apply(T t, U u)

   • 双参数Function

2. ‌BiConsumer<T,U>‌

   • 方法：void accept(T t, U u)

   • 双参数Consumer

3. ‌BiPredicate<T,U>‌

   • 方法：boolean test(T t, U u)

   • 双参数Predicate

四、组合与特殊接口

1. ‌UnaryOperator<T>‌

   • 继承Function<T,T>

   • 输入输出类型相同

2. ‌BinaryOperator<T>‌

   • 继承BiFunction<T,T,T>

   • 两个同类型输入返回同类型结果

3. ‌ObjIntConsumer<T>‌

   • 方法：void accept(T t, int value)

   • 混合对象与基本类型的Consumer

其他重要接口

1. ‌Comparator<T>‌

   • 方法：int compare(T o1, T o2)

   • 排序专用接口

2. ‌Runnable‌

   • 方法：void run()

   • 多线程基础接口

这些接口都使用@FunctionalInterface注解标注，支持lambda表达式和方法引用。实际开发中，90%的场景使用前4个核心接口即可满足需求，特殊场景才会用到其他特化接口。

‌示例‌：

@FunctionalInterface
interface Greeting {void sayHello(String name);
}Greeting greet = name -> System.out.println("Hello, " + name);
greet.sayHello("Alice");

8. 并行流（Parallel Stream）‌

‌理解‌：利用多核CPU并行处理数据。
‌用法‌：通过parallelStream()创建。
‌示例‌：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4);
int sum = numbers.parallelStream().reduce(0, Integer::sum);

Java 8并行流特性详解

一、并行流基本概念

Java 8的并行流(Parallel Stream)是Stream API的一个重要特性，它允许将流操作自动并行化处理，利用多核处理器的优势提高数据处理效率。

二、核心原理

1. ‌Fork/Join框架基础‌

   • 并行流底层使用Fork/Join框架实现

   • 采用工作窃取(work-stealing)算法提高并行效率

   • 默认使用ForkJoinPool.commonPool()线程池

2. ‌分割-执行-合并模式‌

   • 将数据源分割为多个子集

   • 并行处理各个子集

   • 合并处理结果

3. ‌并行度控制‌

   • 默认并行度等于CPU核心数

   • 可通过System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism", "N")调整

三、使用方法

1. 创建并行流

// 从集合创建并行流 List<String> list = Arrays.asList("a", "b", "c"); Stream<String> parallelStream = list.parallelStream(); // 将顺序流转为并行流 Stream<String> stream = Stream.of("a", "b", "c"); Stream<String> parallel = stream.parallel();

2. 常用并行操作

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10); // 并行过滤 List<Integer> evenNumbers = numbers.parallelStream() .filter(n -> n % 2 == 0) .collect(Collectors.toList()); // 并行映射 List<Integer> squaredNumbers = numbers.parallelStream() .map(n -> n * n) .collect(Collectors.toList()); // 并行归约 int sum = numbers.parallelStream() .reduce(0, Integer::sum);

四、性能考虑因素

1. ‌数据量大小‌

   • 小数据集(通常<1000元素)可能不适合并行

   • 大数据集更能体现并行优势

2. ‌操作特性‌

   • 计算密集型操作适合并行

   • I/O密集型操作可能不适合

3. ‌可分解性‌

   • ArrayList、数组等可高效分割

   • LinkedList等分割成本较高

4. ‌合并成本‌

   • 某些操作(如collect)的合并成本可能较高

五、注意事项

1. ‌线程安全问题‌

   • 并行流操作应避免共享可变状态

   • 确保操作是无状态的

2. ‌顺序依赖‌

   • 并行流不保证处理顺序

   • 需要顺序时使用forEachOrdered

3. ‌短路操作‌

   • findFirst等操作在并行下可能性能下降

   • 考虑使用findAny替代

4. ‌副作用‌

   • 避免在并行流中产生副作用

   • 使用线程安全的数据结构或同步机制

六、高级用法

1. ‌自定义线程池‌

ForkJoinPool customPool = new ForkJoinPool(4); customPool.submit(() -> list.parallelStream() .forEach(System.out::println) ).get();

1. ‌避免共享状态‌

// 错误示例 - 共享可变状态 int[] sum = {0}; numbers.parallelStream().forEach(n -> sum[0] += n); // 线程不安全 // 正确做法 int safeSum = numbers.parallelStream().reduce(0, Integer::sum);

1. ‌性能监控‌

long start = System.nanoTime(); result = data.parallelStream().map(...).collect(...); long duration = (System.nanoTime() - start) / 1_000_000; System.out.println("并行处理耗时: " + duration + " ms");

七、适用场景

1. ‌大数据集处理‌

2. ‌计算密集型操作‌

3. ‌无状态、无顺序要求的操作‌

4. ‌可分割的数据源‌

并行流是Java 8中强大的数据处理工具，合理使用可以显著提高性能，但需要根据具体场景谨慎选择。

Java9

‌1. 模块系统（JPMS）‌

‌理解‌：将代码组织成模块，明确依赖关系和访问控制，解决JAR地狱问题。
‌用法‌：在项目根目录创建module-info.java文件。
‌示例‌：

// module-info.java
module com.example.myapp {requires java.base;       // 依赖基础模块requires java.sql;        // 依赖SQL模块exports com.example.util; // 导出包供其他模块使用
}

2. JShell（REPL工具）‌

‌理解‌：交互式命令行工具，直接执行Java代码片段。
‌用法‌：命令行输入jshell，直接输入表达式或代码。
‌示例‌：

jshell> int x = 10;
jshell> System.out.println(x * 2);
20

3. 集合工厂方法‌

‌理解‌：快速创建不可变集合（List、Set、Map）。
‌用法‌：List.of()、Set.of()、Map.of()。
‌示例‌：

List<String> names = List.of("Alice", "Bob", "Charlie");
Set<Integer> numbers = Set.of(1, 2, 3);
Map<String, Integer> scores = Map.of("Alice", 90, "Bob", 85);

‌4. 接口私有方法‌

‌理解‌：接口中可定义私有辅助方法，减少代码重复。
‌用法‌：在接口中使用private修饰方法。
‌示例‌：

interface Logger {default void logInfo(String message) {log(message, "INFO");}private void log(String message, String level) {System.out.println(level + ": " + message);}
}

5. 改进的Stream API‌

‌理解‌：新增takeWhile、dropWhile等方法，增强流控制。
‌用法‌：结合Stream操作。
‌示例‌：

List<Integer> numbers = List.of(1, 2, 3, 4, 5);
List<Integer> result = numbers.stream().takeWhile(n -> n < 4) // 取元素直到条件不满足.collect(Collectors.toList()); // [1, 2, 3]

‌6. 多版本兼容JAR‌

‌理解‌：同一JAR包支持不同Java版本的类文件。
‌用法‌：在MANIFEST.MF中指定Multi-Release: true，目录结构为：

META-INF/versions/9/com/example/MyClass.class

‌7. 改进的Optional‌

‌理解‌：新增ifPresentOrElse、or等方法。
‌用法‌：更灵活处理空值。
‌示例‌：

Optional<String> name = Optional.ofNullable(getName());
name.ifPresentOrElse(System.out::println,() -> System.out.println("Name not found")
);

9. 进程API改进‌

‌理解‌：更强大的进程管理和信息获取。
‌用法‌：通过ProcessHandle获取进程信息。
‌示例‌：

ProcessHandle.current().pid(); // 获取当前进程ID
ProcessHandle.allProcesses()   // 列出所有进程.filter(p -> p.info().command().orElse("").contains("java")).forEach(p -> System.out.println(p.pid()));

10. 响应式流（Flow API）‌

‌理解‌：支持响应式编程的标准接口（Publisher/Subscriber）。
‌用法‌：实现背压控制的异步数据流。
‌示例‌：

SubmissionPublisher<String> publisher = new SubmissionPublisher<>();
publisher.subscribe(new Subscriber<>() {public void onSubscribe(Subscription s) { s.request(1); }public void onNext(String item) { System.out.println(item); }public void onError(Throwable t) { t.printStackTrace(); }public void onComplete() { System.out.println("Done"); }
});
publisher.submit("Hello");

Java10

1. 局部变量类型推断（var）‌

‌理解‌：允许开发者用var声明局部变量，编译器自动推断类型（仅限局部变量，非字段或方法参数）。
‌用法‌：var variable = value;
‌示例‌：

// 传统写法
List<String> names = new ArrayList<>();// Java 10简化
var names = new ArrayList<String>();
var stream = names.stream(); // 自动推断为Stream<String>

‌2. 不可变集合的增强（CopyOf）‌

‌理解‌：List.copyOf()、Set.copyOf()等方法快速创建不可变集合副本。
‌用法‌：基于现有集合生成不可变副本。
‌示例‌：

List<String> original = List.of("A", "B");
List<String> copy = List.copyOf(original); // 不可变副本

‌3. Optional.orElseThrow()‌

‌理解‌：Optional新增无参方法，语义等同于get()但更直观。
‌用法‌：替代get()，明确表示可能抛出异常。
‌示例‌：

Optional<String> name = Optional.ofNullable(getName());
String result = name.orElseThrow(); // 若为null抛出NoSuchElementException

‌4. 并行全垃圾回收器（G1）‌

‌理解‌：G1垃圾回收器在Full GC时改为并行处理，减少停顿时间。
‌用法‌：无需代码调整，JVM自动优化（需启用G1：-XX:+UseG1GC）。

‌5. 线程本地握手（Thread-Local Handshake）‌

‌理解‌：允许在不暂停所有线程的情况下执行线程回调，提升JVM调试和控制能力。
‌用法‌：JVM内部特性，开发者无需直接干预。

‌6. 根证书认证‌

‌理解‌：JDK默认包含CA根证书，支持TLS安全通信。
‌用法‌：自动生效，如HttpsURLConnection无需手动配置证书。

‌7. 应用类数据共享（AppCDS）‌

‌理解‌：扩展类数据共享至应用类，加速启动时间。
‌用法‌：需两步操作：

1. 生成共享存档：java -Xshare:dump
2. 运行应用时加载：java -Xshare:on MyApp

‌8. 基于时间的版本号‌

‌理解‌：版本号改为基于发布周期（如10.0.1），非之前的1.8.0_291格式。

---

‌总结‌

• ‌核心特性‌：var局部变量类型推断是开发者最直接可用的特性。
• ‌性能优化‌：G1并行化和AppCDS提升运行时效率。
• ‌安全增强‌：根证书支持开箱即用的TLS安全。
• ‌不可变集合‌：copyOf()方法简化防御性编程。

Java11

‌1. HTTP Client API（正式版）‌

‌理解‌：标准化Java 9引入的HTTP/2客户端，支持同步/异步请求。

‌用法‌：通过HttpClient发送请求，支持链式调用。

‌示例‌：

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder().uri(URI.create("https://example.com")).GET().build();
// 同步请求
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());// 异步请求
client.sendAsync(request, HttpResponse.BodyHandlers.ofString()).thenApply(HttpResponse::body).thenAccept(System.out::println);

‌2. 局部变量类型推断增强（var for Lambda参数）‌

‌理解‌：允许在Lambda表达式中使用var声明参数（需显式注解@NonNull等）。
‌用法‌：需结合注解使用。
‌示例‌：

List<String> names = List.of("Alice", "Bob");
names.forEach((@NonNull var name) -> System.out.println(name));

‌3. 字符串增强方法‌

‌理解‌：新增isBlank()、lines()、repeat()等方法。
‌用法‌：

String str = "  ";
System.out.println(str.isBlank()); // trueString multiLine = "A\nB\nC";
multiLine.lines().forEach(System.out::println); // 逐行输出String repeated = "Java".repeat(3); // "JavaJavaJava"

4. 新的文件读写方法（Files类）‌

‌理解‌：Files.writeString()和Files.readString()简化文本文件操作。
‌用法‌：

Path path = Path.of("test.txt");
// 写入
Files.writeString(path, "Hello Java 11", StandardCharsets.UTF_8);
// 读取
String content = Files.readString(path);

‌5. 启动单文件源代码程序‌

‌理解‌：直接运行.java文件（无需先编译）。
‌用法‌：

# 直接运行（隐式编译）
java HelloWorld.java

‌6. Epsilon垃圾回收器‌

‌理解‌：无内存回收的GC，适用于性能测试或短生命周期应用。
‌用法‌：启动参数添加-XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC。

---

‌7. 嵌套访问控制（Nest-Based Access Control）‌

‌理解‌：JVM内部优化，允许嵌套类直接访问彼此的私有成员。
‌示例‌：

class Outer {private void outerMethod() {}class Inner {void innerMethod() {outerMethod(); // Java 11允许直接访问}}
}

‌8. 动态类文件常量（JEP 309）‌

‌理解‌：JVM新增CONSTANT_Dynamic常量池类型，提升动态语言支持。

---

‌9. 移除模块和特性‌

‌理解‌：移除Java EE和CORBA模块（如javax.xml.ws），需手动添加依赖。

---

‌10. Flight Recorder（JFR）开源‌

‌理解‌：原商业版JFR成为开源功能，用于低开销性能监控。
‌用法‌：启动参数添加-XX:StartFlightRecording。

Java12-16

以下是Java 12到16的核心特性详解，按版本分类说明：

---

‌Java 12（2019年3月）‌

1. Switch表达式（预览）

‌理解‌：简化switch语法，支持返回值和多标签匹配。
‌用法‌：

int day = 3; String dayType = switch (day) { case 1, 2, 3, 4, 5 -> "Weekday"; case 6, 7 -> "Weekend"; default -> throw new IllegalArgumentException(); };

2. Shenandoah GC（实验性）

‌理解‌：低停顿时间的垃圾回收器，适合大堆内存应用。
‌用法‌：启动参数添加-XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC。

3. Microbenchmark Suite（JMH集成）

‌理解‌：JDK内置微基准测试工具。
‌用法‌：通过jdk.test.lib.包编写性能测试。

---

‌Java 13（2019年9月）‌

1. 文本块（预览）

‌理解‌：简化多行字符串书写，避免转义符。
‌用法‌：

String json = """ { "name": "Java", "version": 13 } """;

2. 动态CDS归档

‌理解‌：优化类数据共享，减少启动时间。
‌用法‌：运行应用时添加-XX:ArchiveClassesAtExit=<file>。

3. Socket API重构

‌理解‌：底层NIO实现优化，提升性能。

---

‌Java 14（2020年3月）‌

1. instanceof模式匹配（预览）

‌理解‌：直接类型转换，减少冗余代码。
‌用法‌：

if (obj instanceof String s) { System.out.println(s.length()); // 直接使用s }

2. Record类（预览）

‌理解‌：简化不可变数据类的定义。
‌用法‌：

record Point(int x, int y) {} Point p = new Point(1, 2); System.out.println(p.x()); // 自动生成getter

3. NullPointerException增强

‌理解‌：明确提示NPE发生的具体变量。
‌输出示例‌：

Cannot invoke "String.length()" because "foo.bar" is null

---

‌Java 15（2020年9月）‌

1. 密封类（Sealed Classes，预览）

‌理解‌：限制类的继承关系。
‌用法‌：

public sealed class Shape permits Circle, Square {} final class Circle extends Shape {} final class Square extends Shape {}

2. 隐藏类（Hidden Classes）

‌理解‌：动态生成类且不暴露给外部，适合框架使用。

3. ZGC（生产就绪）

‌理解‌：可扩展低延迟GC，默认支持。
‌用法‌：-XX:+UseZGC。

---

‌Java 16（2021年3月）‌

1. Record类（正式版）

‌用法‌：同Java 14，移除preview标记。

2. 模式匹配instanceof（正式版）

‌用法‌：同Java 14，移除preview标记。

3. Stream.toList()快捷方法

‌理解‌：简化Stream转List操作。
‌用法‌：

List<String> list = Stream.of("a", "b").toList();

4. Unix域套接字通道

‌理解‌：支持本地进程间通信。
‌用法‌：通过java.nio.channels包操作。

---

‌总结‌

• ‌语法糖‌：switch表达式、文本块、record类显著提升开发效率。
• ‌性能优化‌：ZGC/Shenandoah GC适合低延迟场景。
• ‌工具链‌：动态CDS和JMH增强调试能力。
• ‌稳定性‌：Java 16将多项预览特性转为正式功能。

各版本均需通过--enable-preview启用预览特性（如Java 14的record）。生产环境推荐使用LTS版本（如Java 11/17）。

Java17

1. 密封类（Sealed Classes，正式版）‌

‌理解‌：限制类的继承关系，明确声明哪些类可以继承或实现它。
‌用法‌：

public sealed class Shape permits Circle, Square { // 父类定义 } final class Circle extends Shape {} // 允许的子类 final class Square extends Shape {} // 允许的子类

---

‌2. 模式匹配instanceof（正式版）‌

‌理解‌：简化类型检查和类型转换，减少冗余代码。
‌用法‌：

if (obj instanceof String s) { System.out.println(s.length()); // 直接使用s }

---

‌3. 文本块（正式版）‌

‌理解‌：多行字符串无需转义，保留原始格式。
‌用法‌：

String json = """ { "name": "Java", "version": 17 } """;

---

‌4. Switch表达式增强（正式版）‌

‌理解‌：支持箭头语法和返回值，避免break漏写问题。
‌用法‌：

String dayType = switch (day) { case 1, 2, 3 -> "Weekday"; case 6, 7 -> "Weekend"; default -> "Unknown"; };

---

‌5. 新的垃圾回收器（ZGC/Shenandoah GC）‌

‌理解‌：

• ‌ZGC‌：低延迟GC（默认支持），最大停顿时间<1ms。
• ‌Shenandoah‌：低停顿GC，适合大堆内存。
  ‌用法‌：启动参数添加：
• ZGC: -XX:+UseZGC
• Shenandoah: -XX:+UseShenandoahGC

---

‌6. 移除实验性AOT和JIT编译器‌

‌理解‌：移除GraalVM的实验性支持，需单独安装GraalVM使用。

---

‌7. 外部函数和内存API（孵化器模块）‌

‌理解‌：替代JNI，安全调用本地代码（如C/C++）。
‌用法‌（需启用孵化模块）：

import jdk.incubator.foreign.*; try (MemorySegment segment = MemorySegment.allocateNative(100)) { // 操作本地内存 }

运行命令：java --add-modules jdk.incubator.foreign ...

---

‌8. 伪随机数生成器（新API）‌

‌理解‌：提供更灵活的随机数生成器（如RandomGenerator）。
‌用法‌：

RandomGenerator generator = RandomGenerator.getDefault(); int randomNum = generator.nextInt(100);

---

‌9. 弃用Applet API‌

‌理解‌：彻底移除对Java Applet的支持。

‌10. 强封装JDK内部API‌

‌理解‌：默认禁止反射访问JDK内部API（如sun.misc），需通过--add-opens显式授权。

---

‌总结‌

• ‌语法增强‌：密封类、模式匹配、文本块显著提升代码简洁性。
• ‌性能工具‌：ZGC/Shenandoah GC适合高吞吐或低延迟场景。
• ‌兼容性‌：注意强封装和移除特性对旧项目的影响。
• ‌生产推荐‌：Java 17是LTS版本，建议优先采用。

Java18-20

以下是Java 18到20的核心特性详解，按版本分类说明：

---

‌Java 18（2022年3月）‌

1. 默认UTF-8字符集

‌理解‌：所有Java API默认使用UTF-8编码，避免跨平台乱码问题。
‌用法‌：无需额外配置，String.getBytes()等操作默认按UTF-8处理。

2. 简易Web服务器（jwebserver）

‌理解‌：内置命令行工具，快速启动静态文件服务器。
‌用法‌：

jwebserver -p 8000 -d /path/to/files

3. 模式匹配增强（第二次预览）

‌理解‌：支持switch中的模式匹配和类型推断。
‌用法‌：

Object obj = "Java"; switch (obj) { case String s -> System.out.println(s.length()); case Integer i -> System.out.println(i * 2); default -> {} }

---

‌Java 19（2022年9月）‌

1. 虚拟线程（预览）

‌理解‌：轻量级线程（协程），大幅提升并发性能。
‌用法‌：

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { executor.submit(() -> System.out.println("Virtual Thread")); }

2. 结构化并发（孵化器）

‌理解‌：简化多线程任务的生命周期管理。
‌用法‌：

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) { Future<String> future = scope.fork(() -> "Result"); scope.join(); System.out.println(future.resultNow()); }

3. 外部函数与内存API（第三次预览）

‌理解‌：替代JNI的安全本地代码调用（同Java 17）。

---

‌Java 20（2023年3月）‌

1. 记录模式（Record Patterns，预览）

‌理解‌：解构record类的值，类似模式匹配。
‌用法‌：

record Point(int x, int y) {} Point p = new Point(1, 2); if (p instanceof Point(int x, int y)) { System.out.println(x + "," + y); // 输出: 1,2 }

2. 虚拟线程（第二次预览）

‌用法‌：同Java 19，优化了性能。

3. Scoped Values（孵化器）

‌理解‌：线程内共享不可变数据，替代ThreadLocal。
‌用法‌：

final static ScopedValue<String> USER = ScopedValue.newInstance(); ScopedValue.runWhere(USER, "Alice", () -> { System.out.println(USER.get()); // 输出: Alice });

---

‌总结‌

• ‌并发革命‌：虚拟线程（Java 19+）是最大亮点，适合高并发场景。
• ‌语法糖‌：记录模式（Java 20）和模式匹配持续增强代码简洁性。
• ‌工具链‌：jwebserver（Java 18）方便开发测试。
• ‌实验特性‌：结构化并发和Scoped Values需谨慎评估。

所有预览特性需通过--enable-preview启用，例如：

javac --release 20 --enable-preview Main.java java --enable-preview Main

Java 17仍是当前推荐的生产环境LTS版本，新特性建议在非关键项目试用。

Java21

以下是Java 21（2023年9月发布，LTS版本）的核心特性详解，包含理解、用法和代码示例：

---

‌1. 虚拟线程（正式版）‌

‌理解‌：轻量级线程（协程），由JVM管理而非操作系统，可创建数百万个线程而不会耗尽资源。
‌用法‌：

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) { executor.submit(() -> System.out.println("Hello from virtual thread"));

}

---

‌2. 记录模式（Record Patterns，正式版）‌

‌理解‌：解构record类的值，结合instanceof或switch使用。
‌用法‌：

record Point(int x, int y) {}

Point p = new Point(1, 2);

if (p instanceof Point(int x, int y)) {

System.out.println(x + "," + y); // 输出: 1,2

}

---

‌3. 模式匹配switch（正式版）‌

‌理解‌：switch支持类型匹配和复杂条件判断。
‌用法‌：

Object obj = "Java";

String result = switch (obj) {

case Integer i -> "Number: " + i;

case String s when s.length() > 3 -> "Long string";

case String s -> "String: " + s;

default -> "Unknown";

};

---

‌4. 字符串模板（预览）‌

‌理解‌：简化字符串拼接，支持内嵌表达式。
‌用法‌（需--enable-preview）：

String name = "Java";

String message = STR."Hello \{name}!"; // 输出: Hello Java!

---

‌5. 分代ZGC（正式版）‌

‌理解‌：ZGC新增分代垃圾回收，降低年轻代回收开销。
‌用法‌：启动参数添加-XX:+UseZGC -XX:+ZGenerational。

---

‌6. 有序集合（Sequenced Collections）‌

‌理解‌：为集合（如List、Deque）添加统一的首尾操作API。
‌用法‌：

SequencedCollection<String> list = new ArrayList<>();

list.addFirst("First"); // 添加到开头

list.getLast(); // 获取末尾元素

---

‌7. 外部函数与内存API（正式版）‌

‌理解‌：替代JNI的安全本地代码调用。
‌用法‌：

try (Arena arena = Arena.ofConfined()) {

        MemorySegment segment = arena.allocate(100);

        segment.set(ValueLayout.JAVA_INT, 0, 42); // 写入数据

}

---

‌8. 弃用Windows 32位安装包‌

‌理解‌：不再提供32位Windows的JDK安装包。

---

‌9. 密钥封装机制API（KEM）‌

‌理解‌：支持量子安全的加密算法（如RSA-KEM）。
‌用法‌：

KeyPairGenerator kpg = KeyPairGenerator.getInstance("X25519");

KeyPair kp = kpg.generateKeyPair();

KEM kem = KEM.getInstance("DHKEM");

KEM.Encapsulated e = kem.encapsulate(kp.getPublic());

byte[] secret = e.secret(); // 共享密钥

---

‌总结‌

• ‌并发革命‌：虚拟线程是核心特性，适合高并发微服务。
• ‌语法增强‌：记录模式、模式匹配switch提升代码简洁性。
• ‌安全与性能‌：分代ZGC和KEM API强化安全与效率。
• ‌预览特性‌：字符串模板需手动启用预览功能。

生产环境推荐Java 21（LTS），预览特性需通过以下参数启用：

javac --release 21 --enable-preview Main.java java --enable-preview Main