Java 15 新特性解析與代碼示例

引言

Java 15（JDK 15）于2020年9月15日發布，作為Java快速發布周期（每六個月一次）的一部分，帶來了多項新特性和改進。這些特性涵蓋語言增強、API改進和JVM優化，旨在提升開發者的生產力、代碼可讀性和程序性能。本文將深入探討Java 15的關鍵特性，包括密封類、模式匹配、記錄、文本塊等，并為每個特性提供詳細的代碼示例和與傳統方法的對比。我們還將介紹其他重要更新，如隱藏類、外部內存訪問API、垃圾回收器改進等。

本文的目標是為開發者提供"硬核"且實用的內容，確保讀者在閱讀后能夠理解每個特性的用途并能將其應用于實際項目中。需要注意的是：

1. 密封類、模式匹配和記錄是預覽特性，需使用--enable-preview標志啟用
2. 外部內存訪問API是孵化特性，需使用--add-modules jdk.incubator.foreign啟用
3. 部分特性在不同Java版本中的狀態不同，使用時需注意版本兼容性

以下是Java 15的主要新特性列表：

1. 密封類（Sealed Classes，JEP 360，預覽特性）
2. instanceof模式匹配（Pattern Matching for instanceof，JEP 375，預覽特性）
3. 記錄（Records，JEP 384，預覽特性）
4. 文本塊（Text Blocks，JEP 378，正式特性）
5. 隱藏類（Hidden Classes，JEP 371）
6. 外部內存訪問API（Foreign-Memory Access API，JEP 383，孵化特性）
7. ZGC和Shenandoah垃圾回收器（JEP 377和JEP 379，生產就緒）
8. Unicode 13.0支持
9. CharSequence的isEmpty方法
10. EdDSA加密支持（JEP 339）

讓我們逐一深入分析這些特性。

1. 密封類（Sealed Classes）

1.1. 什么是密封類？

密封類是Java 15引入的預覽特性（JEP 360），允許開發者限制哪些類可以擴展某個類或實現某個接口。通過使用sealed關鍵字和permits子句，開發者可以明確指定允許的子類，從而控制繼承層次。這種機制特別適合需要嚴格定義類層次結構的場景，例如在領域建模中限制可能的子類型。

1.2. 為什么使用密封類？

密封類提供了以下優勢：

• 控制繼承：防止意外的子類擴展，確保只有指定的類可以繼承。
• 窮盡性模式匹配：與模式匹配結合使用時，編譯器可以驗證是否處理了所有可能的子類。
• 代碼清晰性：明確類層次結構，減少維護復雜性。
• 性能優化：JVM可以利用密封類的有限子類信息進行優化。

1.3. 語法

密封類的定義使用sealed關鍵字，并在permits子句中列出允許的子類。子類必須是final、sealed或non-sealed之一。

non-sealed允許子類被自由擴展，提供了密封類層次結構中的靈活性。

示例：

public sealed class Shape permits Circle, Rectangle, Triangle {public abstract void draw();
}public final class Circle extends Shape {@Overridepublic void draw() {System.out.println("Drawing a circle");}
}public final class Rectangle extends Shape {@Overridepublic void draw() {System.out.println("Drawing a rectangle");}
}public non-sealed class Triangle extends Shape {@Overridepublic void draw() {System.out.println("Drawing a triangle");}
}// Triangle是非密封的，可以自由擴展
class RightTriangle extends Triangle {@Overridepublic void draw() {System.out.println("Drawing a right triangle");}
}

在這個例子中，Shape是一個密封類，只允許Circle、Rectangle和Triangle擴展它。Triangle被聲明為non-sealed，因此可以進一步被RightTriangle擴展。

1.4. 與傳統方法的對比

在Java 15之前，控制繼承通常有以下方法：

• 使用final類：完全禁止擴展，但無法允許任何子類。
• 使用包訪問控制：通過將類放在同一包中并限制訪問權限來控制繼承，但這種方法不夠靈活。
• 使用接口和實現類：但無法限制哪些類可以實現接口。

密封類通過sealed、permits、final和non-sealed的組合，提供了更靈活和明確的繼承控制機制。

1.5. 使用場景

密封類在以下場景中特別有用：

• 領域建模：例如，在金融系統中定義一組固定的交易類型。
• API設計：限制哪些類可以實現某個接口，確保API的正確使用。
• 模式匹配：與instanceof模式匹配結合，實現窮盡性檢查。

1.6. 示例：結合模式匹配

密封類與模式匹配結合可以實現更安全的類型處理。以下是一個完整示例：

public sealed class Shape permits Circle, Rectangle {public abstract double area();
}public final class Circle extends Shape {private final double radius;public Circle(double radius) {this.radius = radius;}@Overridepublic double area() {return Math.PI * radius * radius;}
}public final class Rectangle extends Shape {private final double width, height;public Rectangle(double width, double height) {this.width = width;this.height = height;}@Overridepublic double area() {return width * height;}
}public class ShapeCalculator {public static void printArea(Shape shape) {// 編譯器知道Shape只有Circle和Rectangle兩種子類if (shape instanceof Circle c) {System.out.println("Circle area: " + c.area());} else if (shape instanceof Rectangle r) {System.out.println("Rectangle area: " + r.area());}// 不需要else分支，因為所有可能性都已處理}public static void main(String[] args) {Shape circle = new Circle(5.0);Shape rectangle = new Rectangle(4.0, 6.0);printArea(circle);     // 輸出：Circle area: 78.53981633974483printArea(rectangle);  // 輸出：Rectangle area: 24.0}
}

注意：由于密封類是預覽特性，編譯和運行時需使用--enable-preview標志：

javac --enable-preview --release 15 ShapeCalculator.java
java --enable-preview ShapeCalculator

2. instanceof 模式匹配（Pattern Matching for instanceof）

2.1. 什么是模式匹配？

instanceof模式匹配是Java 15的預覽特性（JEP 375），允許在類型檢查的同時聲明一個變量，直接使用該變量而無需顯式類型轉換。這減少了樣板代碼，提高了代碼的可讀性和安全性。

2.2. 語法

傳統方式：

if (obj instanceof String) {String str = (String) obj;  // 需要顯式轉換System.out.println(str.toUpperCase());
}

使用模式匹配：

if (obj instanceof String str) {  // 自動轉換并賦值給strSystem.out.println(str.toUpperCase());// str的作用域僅限于這個if塊內
}

在模式匹配中，str是一個綁定變量，如果obj是String類型，則自動轉換為String并賦值給str。注意變量的作用域僅限于對應的if塊內。

2.3. 優點

• 簡潔性：將類型檢查和轉換合并為一行。
• 可讀性：代碼更直觀，邏輯更清晰。
• 安全性：避免了手動類型轉換可能導致的ClassCastException。

2.4. 與密封類的結合

模式匹配與密封類結合時，編譯器可以確保所有可能的子類都被處理。例如：

public void handleShape(Shape shape) {if (shape instanceof Circle c) {c.draw();} else if (shape instanceof Rectangle r) {r.draw();}// 不需要else分支，編譯器知道Shape只有這兩種子類
}

2.5. 示例

以下是一個結合密封類和模式匹配的完整示例：

public class PatternMatchingExample {public static void process(Object obj) {if (obj instanceof String s) {System.out.println("String length: " + s.length());} else if (obj instanceof Integer i && i > 0) {System.out.println("Positive integer: " + i);} else if (obj instanceof Double d) {System.out.println("Double value: " + d);} else {System.out.println("Unknown type: " + obj.getClass());}}public static void main(String[] args) {process("Hello");    // 輸出：String length: 5process(42);         // 輸出：Positive integer: 42process(3.14);       // 輸出：Double value: 3.14process(new Object());// 輸出：Unknown type: class java.lang.Object}
}

注意：模式匹配是預覽特性，需啟用--enable-preview。

3. 記錄（Records）

3.1. 什么是記錄？

記錄（Records）是Java 14引入并在Java 15繼續作為預覽特性的功能（JEP 384）。記錄是一種特殊的類，專為攜帶不可變數據設計，自動生成構造函數、訪問器、toString、equals和hashCode方法。

記錄有以下限制：

• 隱含final，不能是abstract
• 不能顯式擴展其他類（隱含擴展Record類）
• 所有字段都是final的
• 不能聲明實例字段（只能在記錄頭中聲明）

3.2. 語法

記錄的定義非常簡潔：

public record Point(int x, int y) {}

這等同于以下傳統類：

public final class Point {private final int x;private final int y;public Point(int x, int y) {this.x = x;this.y = y;}public int x() { return x; }public int y() { return y; }@Overridepublic String toString() {return "Point[x=" + x + ", y=" + y + "]";}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Point point = (Point) o;return x == point.x && y == point.y;}@Overridepublic int hashCode() {return Objects.hash(x, y);}
}

3.3. 優點

• 簡潔性：減少了大量樣板代碼。
• 不可變性：記錄默認不可變，適合線程安全和功能式編程。
• 一致性：自動生成的方法遵循標準約定。

3.4. 使用場景

記錄適用于：

• 數據傳輸對象（DTO）：在層與層之間傳遞數據。
• 元組：臨時組合多個值。
• 功能式編程：與Stream API等結合使用。

3.5. 示例

以下是一個使用記錄計算兩點距離的示例：

public record Point(int x, int y) {// 可以在記錄中添加自定義方法public double distanceTo(Point other) {int dx = x - other.x();int dy = y - other.y();return Math.sqrt(dx * dx + dy * dy);}
}public class PointDistance {public static void main(String[] args) {Point p1 = new Point(0, 0);Point p2 = new Point(3, 4);// 使用自動生成的toString()System.out.println("Point 1: " + p1);  // 輸出：Point 1: Point[x=0, y=0]// 使用自定義方法double dist = p1.distanceTo(p2);System.out.println("Distance: " + dist);  // 輸出：Distance: 5.0// 使用自動生成的equals()System.out.println("Equal points: " + p1.equals(new Point(0, 0)));  // 輸出：true}
}

注意：記錄是預覽特性，需啟用--enable-preview。

4. 文本塊（Text Blocks）

4.1. 什么是文本塊？

文本塊（Text Blocks）是Java 13引入預覽、Java 14二次預覽并在Java 15成為正式特性的功能（JEP 378）。它允許開發者以自然的方式定義多行字符串，無需使用轉義字符或字符串拼接。

4.2. 語法

文本塊使用三重引號（"""）定義：

String html = """<html><body><p>Hello, world</p></body></html>""";

文本塊中的空白行會被保留。如果一行只包含縮進空格，它會被視為空白行而不是空字符串。

4.3. 優點

• 可讀性：多行字符串更直觀。
• 減少轉義：無需手動轉義引號或換行符。
• 縮進控制：支持自然的代碼縮進。

4.4. 縮進處理

文本塊默認保留代碼中的縮進。如果需要去除前導空格，可以使用String.stripIndent()方法：

String html = """<html><body><p>Hello</p></body></html>""".stripIndent();

4.5. 示例

以下是一個使用文本塊定義JSON的示例：

String json = """{"name": "John","age": 30,"city": "New York","hobbies": ["reading","traveling"]}""";System.out.println(json);

SQL查詢示例：

String query = """SELECT u.id, u.name, COUNT(o.id) AS order_countFROM users uLEFT JOIN orders o ON u.id = o.user_idWHERE u.active = trueGROUP BY u.id, u.nameHAVING COUNT(o.id) > 0ORDER BY order_count DESC""";

5. 隱藏類（Hidden Classes）

5.1. 什么是隱藏類？

隱藏類（Hidden Classes，JEP 371）是Java 15引入的特性，允許JVM在運行時創建不可見的類。這些類不注冊在常量池中，無法通過反射訪問，主要用于優化JVM內部實現，如lambda表達式和方法句柄。

5.2. 為什么重要？

隱藏類提高了性能和內存效率：

• 減少內存占用：避免創建命名類的開銷。
• 提高封裝性：隱藏實現細節，防止外部訪問。
• 優化堆棧跟蹤：使lambda表達式的堆棧跟蹤更清晰。

開發者也可以通過MethodHandles.Lookup.defineHiddenClass方法顯式創建隱藏類，但這通常只在需要高度動態類加載的高級場景中使用。

5.3. 示例

隱藏類通常由JVM內部使用，例如：

List<String> list = Arrays.asList("a", "b", "c");
list.forEach(s -> System.out.println(s));  // lambda由隱藏類實現

6. 外部內存訪問API（Foreign-Memory Access API）

6.1. 什么是外部內存訪問API？

外部內存訪問API（JEP 383）是Java 15的孵化特性，允許Java程序安全高效地訪問堆外內存（如本地內存）。它是Project Panama的一部分，旨在改善Java與本地代碼的互操作性。

6.2. 用途

• 高性能數據處理：直接操作大塊數據，避免復制到Java堆。
• 本地庫交互：與C/C++庫共享內存。
• 內存映射文件：直接訪問文件內容。

6.3. 示例

以下是一個安全使用外部內存訪問API的示例：

import jdk.incubator.foreign.MemorySegment;
import jdk.incubator.foreign.ResourceScope;public class ForeignMemoryExample {public static void main(String[] args) {try {try (ResourceScope scope = ResourceScope.newConfinedScope()) {MemorySegment segment = MemorySegment.allocateNative(10, scope);// 寫入數據for (int i = 0; i < 10; i++) {segment.setAtIndex(byte.class, i, (byte)(65 + i));}// 讀取數據for (int i = 0; i < 10; i++) {System.out.print((char) segment.getAtIndex(byte.class, i));}// 輸出：ABCDEFGHIJ}} catch (Exception e) {e.printStackTrace();}}
}

注意：此特性需要啟用孵化模塊：

javac --add-modules jdk.incubator.foreign ForeignMemoryExample.java
java --add-modules jdk.incubator.foreign ForeignMemoryExample

7. 垃圾回收器：ZGC和Shenandoah

7.1. ZGC

ZGC（Z Garbage Collector，JEP 377）是低延遲、高可擴展性的垃圾回收器，適合大堆內存和低暫停時間需求的應用。在Java 15中，ZGC正式成為生產就緒特性。

啟用方式：

java -XX:+UseZGC YourApp

7.2. Shenandoah

Shenandoah（JEP 379）是另一個低延遲垃圾回收器，強調并發標記和壓縮。在Java 15中也成為生產就緒特性。

啟用方式：

java -XX:+UseShenandoahGC YourApp

7.3. 選擇建議

垃圾回收器	最大堆大小	平均暫停時間	適用場景
ZGC	16TB	<10ms	超大堆、極低延遲
Shenandoah	數TB	<10ms	大堆、平衡吞吐量
G1	數十GB	<200ms	大多數通用應用

8. Unicode 13.0支持

Java 15支持Unicode 13.0，新增5930個字符（總計143859個），4個新腳本（總計154個）和55個新emoji字符。這對國際化應用至關重要，確保Java能處理最新的字符和腳本。

9. CharSequence的isEmpty方法

Java 15為CharSequence接口添加了默認方法isEmpty()，用于檢查字符序列是否為空。

示例：

CharSequence seq = "";
if (seq.isEmpty()) {  // 比seq.length() == 0更直觀System.out.println("Sequence is empty");
}

10. EdDSA加密支持

10.1. 什么是EdDSA？

EdDSA（Edwards-curve Digital Signature Algorithm，JEP 339）是Java 15引入的現代數字簽名算法，基于橢圓曲線加密，提供高性能和高安全性。

EdDSA相比傳統ECDSA有以下優勢：

• 更高的性能
• 更強的安全性
• 更簡單的密鑰生成
• 天然抵抗側信道攻擊

10.2. 示例

以下是使用EdDSA簽名和驗證的示例：

import java.security.*;
import java.util.Base64;public class EdDSAExample {public static void main(String[] args) throws Exception {// 生成密鑰對KeyPairGenerator kpg = KeyPairGenerator.getInstance("Ed25519");KeyPair kp = kpg.generateKeyPair();// 簽名Signature sig = Signature.getInstance("Ed25519");sig.initSign(kp.getPrivate());byte[] message = "Important message".getBytes();sig.update(message);byte[] signature = sig.sign();System.out.println("Signature: " + Base64.getEncoder().encodeToString(signature));// 驗證sig.initVerify(kp.getPublic());sig.update(message);boolean verified = sig.verify(signature);System.out.println("Verified: " + verified);  // 輸出：true}
}

11. 其他特性

• Nashorn JavaScript引擎移除（JEP 372）：Nashorn引擎被移除，建議使用GraalVM等替代方案。
• RMI激活機制棄用（JEP 385）：RMI激活機制被標記為即將移除。
• DatagramSocket API重實現（JEP 373）：優化了舊的DatagramSocket實現，提高性能。

12. 結語

Java 15通過引入密封類、模式匹配、記錄和文本塊等特性，顯著提升了語言的表達力和開發效率。隱藏類和外部內存訪問API優化了JVM性能，而ZGC和Shenandoah的成熟為低延遲應用提供了更多選擇。Unicode 13.0和EdDSA支持進一步增強了Java的國際化能力和安全性。

開發者應嘗試這些新特性，尤其是在測試環境中探索預覽和孵化特性。使用預覽特性時，記得啟用--enable-preview標志；使用孵化特性時，需啟用相應模塊。未來版本可能會對這些特性進行調整或正式化，因此保持關注是明智的選擇。

參考資料

• JDK 15 Release Notes
• Java 15 Features on javaalmanac.io
• OpenJDK JEP Index
• Java Language Updates