Java8-21的核心特性以及用法

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()。
原理：
? ?
?封裝與空安全?
本質是泛型不可變容器類（final class Optional<T>）
通過私有構造器強制要求非空值必須顯式包裝
空值統一用private static final Optional<?> EMPTY表示
?核心實現機制?
值存儲：private final T value字段存儲實際對象
空檢查：所有方法內部首先檢查value == null
鏈式調用：方法返回新Optional實例保證不可變性
?關鍵方法實現?
of()：直接賦值前進行非空校驗（Objects.requireNonNull）
ofNullable()：允許傳入null值，內部轉為EMPTY實例
map()/flatMap()：通過函數式接口實現惰性求值
orElse()：通過Supplier延遲備選值計算
?線程安全設計?
所有字段聲明為final（包括存儲的value）
不提供修改內部狀態的方法
每次操作返回新實例（類似String的不可變性）
?性能優化點?
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包中：
一、核心函數式接口
?Function<T,R>?
方法：R apply(T t)
用途：接受一個輸入返回一個結果
?Consumer<T>?
方法：void accept(T t)
用途：消費一個輸入不返回結果
?Supplier<T>?
方法：T get()
用途：無輸入返回一個值
?Predicate<T>?
方法：boolean test(T t)
用途：輸入判斷返回布爾值
二、原始類型特化接口
?IntFunction<R>? / ?DoubleFunction<R>?
專為基本類型優化的Function
?ToIntFunction<T>? / ?ToDoubleFunction<T>?
返回基本類型的Function
?IntConsumer? / ?DoubleConsumer?
基本類型的Consumer
三、二元操作接口
?BiFunction<T,U,R>?
方法：R apply(T t, U u)
雙參數Function
?BiConsumer<T,U>?
方法：void accept(T t, U u)
雙參數Consumer
?BiPredicate<T,U>?
方法：boolean test(T t, U u)
雙參數Predicate
四、組合與特殊接口
?UnaryOperator<T>?
繼承Function<T,T>
輸入輸出類型相同
?BinaryOperator<T>?
繼承BiFunction<T,T,T>
兩個同類型輸入返回同類型結果
?ObjIntConsumer<T>?
方法：void accept(T t, int value)
混合對象與基本類型的Consumer
其他重要接口
?Comparator<T>?
方法：int compare(T o1, T o2)
排序專用接口
?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的一個重要特性，它允許將流操作自動并行化處理，利用多核處理器的優勢提高數據處理效率。
二、核心原理
?Fork/Join框架基礎?
并行流底層使用Fork/Join框架實現
采用工作竊取(work-stealing)算法提高并行效率
默認使用ForkJoinPool.commonPool()線程池
?分割-執行-合并模式?
將數據源分割為多個子集
并行處理各個子集
合并處理結果
?并行度控制?
默認并行度等于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);
四、性能考慮因素
?數據量大小?
小數據集(通常<1000元素)可能不適合并行
大數據集更能體現并行優勢
?操作特性?
計算密集型操作適合并行
I/O密集型操作可能不適合
?可分解性?
ArrayList、數組等可高效分割
LinkedList等分割成本較高
?合并成本?
某些操作(如collect)的合并成本可能較高
五、注意事項
?線程安全問題?
并行流操作應避免共享可變狀態
確保操作是無狀態的
?順序依賴?
并行流不保證處理順序
需要順序時使用forEachOrdered
?短路操作?
findFirst等操作在并行下可能性能下降
考慮使用findAny替代
?副作用?
避免在并行流中產生副作用
使用線程安全的數據結構或同步機制
六、高級用法
?自定義線程池?
ForkJoinPool customPool = new ForkJoinPool(4); customPool.submit(() -> list.parallelStream() .forEach(System.out::println) ).get();
?避免共享狀態?
// 錯誤示例 - 共享可變狀態 int[] sum = {0}; numbers.parallelStream().forEach(n -> sum[0] += n); // 線程不安全 // 正確做法 int safeSum = numbers.parallelStream().reduce(0, Integer::sum);
?性能監控?
long start = System.nanoTime(); result = data.parallelStream().map(...).collect(...); long duration = (System.nanoTime() - start) / 1_000_000; System.out.println("并行處理耗時: " + duration + " ms");
七、適用場景
?大數據集處理?
?計算密集型操作?
?無狀態、無順序要求的操作?
?可分割的數據源?
并行流是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）?
?理解?：擴展類數據共享至應用類，加速啟動時間。
?用法?：需兩步操作：
生成共享存檔：java -Xshare:dump
運行應用時加載：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