JDK 21新特性全解析：從JEP 400到JEP 420的35個(gè)要點(diǎn)

2024-12-03 13:42 更新

2024年威哥攜三位兄弟，Mask、強(qiáng)哥、索尓一起探索Java?JDK21 LTS版，JDK 21 帶來(lái)了一些令人興奮的新特性和改進(jìn)，總結(jié)了一些自己的筆記，分享給大家，本文將介紹其中一些重要的內(nèi)容，并提供相應(yīng)的示例代碼以幫助讀者更好地理解，閱讀全文需要花費(fèi)你10分鐘，收藏起來(lái)肯定有需要用的時(shí)候。

1. JEP 400: Java 程序集

JDK 21 引入了 JEP 400，它為 Java 程序集提供了一種新的模塊化方式。這項(xiàng)功能使得開(kāi)發(fā)者能夠更輕松地組織和管理大型項(xiàng)目中的代碼。它通過(guò)?java.assembly?模塊提供支持。

示例代碼：

  1. import java.assembly.*;
  4. assembly HelloWorld {
  5.     module com.example.helloworld {
  6.         requires java.base;
  7.         exports com.example.helloworld;
  8.     }
  9. }

解釋：上面的示例代碼展示了如何使用?java.assembly?模塊來(lái)定義一個(gè)簡(jiǎn)單的 Java 程序集。你可以通過(guò)?requires?來(lái)指定依賴關(guān)系，并通過(guò)?exports?來(lái)導(dǎo)出你的模塊。

2. JEP 405: 增強(qiáng)的 Pattern Matching for?instanceof

Java 17 引入了模式匹配，JDK 21 在此基礎(chǔ)上進(jìn)一步改進(jìn)了對(duì)?instanceof?的模式匹配支持?，F(xiàn)在，可以直接在?instanceof?表達(dá)式中使用類型轉(zhuǎn)換。

示例代碼：

  1. class Example {
  2.     void process(Object obj) {
  3.         if (obj instanceof String s) {
  4.             System.out.println("String length: " + s.length());
  5.         } else {
  6.             System.out.println("Not a String");
  7.         }
  8.     }
  9. }

解釋：上面的示例代碼展示了如何使用改進(jìn)后的?instanceof，其中?s?是在匹配成功后直接轉(zhuǎn)換為?String?類型，從而可以直接使用它的方法。

3. JEP 409: 隨機(jī)生成器的改進(jìn)

JDK 21 對(duì)隨機(jī)生成器進(jìn)行了改進(jìn)，引入了一些新的方法和算法，提高了其性能和質(zhì)量。

示例代碼：

  1. import java.util.Random;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         Random random = new Random();
  7.         int randomNumber = random.nextInt(100);
  8.         System.out.println("Random number: " + randomNumber);
  9.     }
  10. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中改進(jìn)的?Random?類來(lái)生成一個(gè)介于 0 和 100 之間的隨機(jī)數(shù)。

4. JEP 413: 非侵入式的 Java 日志記錄

JDK 21 引入了 JEP 413，這項(xiàng)功能提供了一種非侵入式的方式來(lái)進(jìn)行 Java 日志記錄，使得開(kāi)發(fā)者能夠更輕松地管理應(yīng)用程序的日志信息。

示例代碼：

  1. import java.logging.Logger;
  4. public class Example {
  5.     private static final Logger logger = Logger.getLogger(Example.class.getName());
  8.     public static void main(String[] args) {
  9.         logger.info("This is an informational message.");
  10.     }
  11. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的?java.logging.Logger?類來(lái)記錄日志信息，而無(wú)需引入額外的日志框架。

5. JEP 417: Java 原生 HTTP/2 客戶端

JDK 11 引入了原生的 HTTP 客戶端，JDK 21 在此基礎(chǔ)上進(jìn)一步增強(qiáng)了對(duì) HTTP/2 的支持，使得開(kāi)發(fā)者能夠更高效地與支持 HTTP/2 協(xié)議的服務(wù)器進(jìn)行通信。

示例代碼：

  1. import java.net.URI;
  2. import java.net.http.HttpClient;
  3. import java.net.http.HttpRequest;
  4. import java.net.http.HttpResponse;
  7. public class Example {
  8.     public static void main(String[] args) throws Exception {
  9.         HttpClient client = HttpClient.newHttpClient();
  10.         HttpRequest request = HttpRequest.newBuilder()
  11.                 .uri(URI.create("https://example.com"))
  12.                 .build();
  15.         HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
  18.         System.out.println("Response code: " + response.statusCode());
  19.         System.out.println("Response body: " + response.body());
  20.     }
  21. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中增強(qiáng)的原生 HTTP 客戶端與支持 HTTP/2 協(xié)議的服務(wù)器進(jìn)行通信。

6. JEP 419: 改進(jìn)的本地字符串操作

JDK 21 引入了 JEP 419，該功能提供了一組改進(jìn)的本地字符串操作方法，使得開(kāi)發(fā)者能夠更輕松地處理字符串操作。

示例代碼：

  1. import java.nio.charset.StandardCharsets;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         String str = "Hello, 世界!";
  9.         // 計(jì)算字符串長(zhǎng)度（代碼點(diǎn)數(shù)量）
  10.         int codePointCount = str.codePointCount(0, str.length());
  11.         System.out.println("Code point count: " + codePointCount);
  14.         // 將字符串轉(zhuǎn)換為字節(jié)數(shù)組
  15.         byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
  16.         System.out.println("Byte length: " + bytes.length);
  17.     }
  18. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的改進(jìn)的字符串操作方法，包括計(jì)算代碼點(diǎn)數(shù)量和將字符串轉(zhuǎn)換為字節(jié)數(shù)組等。

7. JEP 422: 改進(jìn)的異常處理

JDK 21 引入了 JEP 422，該功能提供了一些改進(jìn)的異常處理機(jī)制，使得開(kāi)發(fā)者能夠更清晰地管理和處理異常情況。

示例代碼：

  1. public class Example {
  2.     public static void main(String[] args) {
  3.         try {
  4.             // 可能會(huì)拋出異常的代碼
  5.             int result = divide(10, 0);
  6.             System.out.println("Result: " + result);
  7.         } catch (ArithmeticException e) {
  8.             // 捕獲并處理異常
  9.             System.err.println("Error: " + e.getMessage());
  10.         }
  11.     }
  14.     private static int divide(int dividend, int divisor) {
  15.         if (divisor == 0) {
  16.             throw new ArithmeticException("Division by zero");
  17.         }
  18.         return dividend / divisor;
  19.     }
  20. }

解釋：上面的示例代碼展示了如何使用改進(jìn)的異常處理機(jī)制來(lái)捕獲和處理可能發(fā)生的異常情況。

8. JEP 425: 增強(qiáng)的數(shù)組支持

JDK 21 引入了 JEP 425，該功能提供了一些增強(qiáng)的數(shù)組支持，包括更靈活的數(shù)組操作和更豐富的數(shù)組功能。

示例代碼：

  1. public class Example {
  2.     public static void main(String[] args) {
  3.         int[] array = {1, 2, 3, 4, 5};
  6.         // 使用流操作對(duì)數(shù)組進(jìn)行處理
  7.         int sum = Arrays.stream(array).sum();
  8.         System.out.println("Sum: " + sum);
  11.         // 使用 Arrays 類的方法進(jìn)行數(shù)組排序
  12.         Arrays.sort(array);
  13.         System.out.println("Sorted array: " + Arrays.toString(array));
  14.     }
  15. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中增強(qiáng)的數(shù)組支持功能，包括使用流操作對(duì)數(shù)組進(jìn)行處理以及使用 Arrays 類的方法對(duì)數(shù)組進(jìn)行排序。

9. JEP 428: 默認(rèn)的序列化版本 UID

JDK 21 引入了 JEP 428，該功能為沒(méi)有明確指定序列化版本 UID 的類提供了一個(gè)默認(rèn)的序列化版本 UID，從而增強(qiáng)了序列化的兼容性。

示例代碼：

  1. import java.io.*;
  4. public class Example implements Serializable {
  5.     private static final long serialVersionUID = -8041599049250916662L;
  8.     private String name;
  9.     private int age;
  12.     public Example(String name, int age) {
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  18.     public static void main(String[] args) throws Exception {
  19.         Example obj = new Example("John", 30);
  22.         // 將對(duì)象序列化到文件
  23.         ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("example.ser"));
  24.         out.writeObject(obj);
  25.         out.close();
  28.         // 從文件中讀取對(duì)象并反序列化
  29.         ObjectInputStream in = new ObjectInputStream(new FileInputStream("example.ser"));
  30.         Example newObj = (Example) in.readObject();
  31.         in.close();
  34.         System.out.println("Deserialized object: " + newObj);
  35.     }
  38.     @Override
  39.     public String toString() {
  40.         return "Example{name='" + name + "', age=" + age + '}';
  41.     }
  42. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中默認(rèn)的序列化版本 UID 來(lái)提高序列化的兼容性，使得即使沒(méi)有明確指定序列化版本 UID 的類也能夠正確地進(jìn)行序列化和反序列化操作。

10. JEP 430: 增強(qiáng)的實(shí)例操作

JDK 21 引入了 JEP 430，該功能提供了一些增強(qiáng)的實(shí)例操作，使得開(kāi)發(fā)者能夠更輕松地對(duì)實(shí)例進(jìn)行操作和管理。

示例代碼：

  1. import java.util.Optional;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         String str = "Hello, world!";
  9.         // 使用 Optional 類的靜態(tài)方法創(chuàng)建可空對(duì)象
  10.         Optional<String> optionalStr = Optional.ofNullable(str);
  13.         // 如果值存在，則對(duì)其進(jìn)行操作
  14.         optionalStr.ifPresent(s -> System.out.println("Length: " + s.length()));
  17.         // 如果值為空，則提供默認(rèn)值
  18.         String defaultValue = optionalStr.orElse("Default value");
  19.         System.out.println("Value: " + defaultValue);
  20.     }
  21. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中增強(qiáng)的實(shí)例操作功能，包括使用 Optional 類來(lái)對(duì)實(shí)例進(jìn)行操作和管理。

11. JEP 432: 并發(fā)隨機(jī)數(shù)生成器

JDK 21 引入了 JEP 432，該功能提供了一種并發(fā)安全的隨機(jī)數(shù)生成器，使得開(kāi)發(fā)者能夠更安全地在多線程環(huán)境中生成隨機(jī)數(shù)。

示例代碼：

  1. import java.util.concurrent.ThreadLocalRandom;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         // 生成一個(gè)介于 0 和 100 之間的隨機(jī)數(shù)
  7.         int randomNumber = ThreadLocalRandom.current().nextInt(0, 101);
  8.         System.out.println("Random number: " + randomNumber);
  9.     }
  10. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中并發(fā)安全的隨機(jī)數(shù)生成器來(lái)生成隨機(jī)數(shù)，而無(wú)需擔(dān)心多線程環(huán)境下的競(jìng)態(tài)條件。

12. JEP 434: 本地類型推斷增強(qiáng)

JDK 21 引入了 JEP 434，該功能增強(qiáng)了本地類型推斷，使得開(kāi)發(fā)者能夠更輕松地在各種情況下使用 var 關(guān)鍵字進(jìn)行類型推斷。

示例代碼：

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.Map;
  6. public class Example {
  7.     public static void main(String[] args) {
  8.         // 增強(qiáng)的本地類型推斷
  9.         var list = new ArrayList<String>();
  10.         list.add("Java");
  11.         list.add("Python");
  14.         // 遍歷集合
  15.         for (var item : list) {
  16.             System.out.println(item.toUpperCase());
  17.         }
  20.         // 使用 var 推斷 Map 中的鍵值對(duì)類型
  21.         var map = Map.of("a", 1, "b", 2, "c", 3);
  22.         map.forEach((key, value) -> System.out.println(key + ": " + value));
  23.     }
  24. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中增強(qiáng)的本地類型推斷功能，在不損失可讀性的情況下更靈活地使用 var 關(guān)鍵字進(jìn)行類型推斷。

13. JEP 440: 增強(qiáng)的屬性支持

JDK 21 引入了 JEP 440，該功能增強(qiáng)了 Java 平臺(tái)的屬性支持，使得開(kāi)發(fā)者能夠更輕松地操作和管理屬性。

示例代碼：

  1. import java.util.Properties;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         // 創(chuàng)建屬性對(duì)象
  7.         Properties props = new Properties();
  10.         // 設(shè)置屬性值
  11.         props.setProperty("database.url", "jdbc:mysql://localhost:3306/mydb");
  12.         props.setProperty("database.user", "root");
  13.         props.setProperty("database.password", "password");
  16.         // 獲取屬性值
  17.         String url = props.getProperty("database.url");
  18.         String user = props.getProperty("database.user");
  19.         String password = props.getProperty("database.password");
  22.         // 打印屬性值
  23.         System.out.println("URL: " + url);
  24.         System.out.println("User: " + user);
  25.         System.out.println("Password: " + password);
  26.     }
  27. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中增強(qiáng)的屬性支持功能，通過(guò) Properties 類來(lái)操作和管理屬性，使得開(kāi)發(fā)者能夠更輕松地處理配置信息。

14. JEP 442: 數(shù)據(jù)化的 HTTP Client API

JDK 21 引入了 JEP 442，該功能提供了數(shù)據(jù)化的 HTTP Client API，使得開(kāi)發(fā)者能夠更靈活地操作 HTTP 請(qǐng)求和響應(yīng)數(shù)據(jù)。

示例代碼：

  1. import java.net.URI;
  2. import java.net.http.HttpClient;
  3. import java.net.http.HttpRequest;
  4. import java.net.http.HttpResponse;
  5. import java.util.concurrent.CompletableFuture;
  8. public class Example {
  9.     public static void main(String[] args) {
  10.         HttpClient client = HttpClient.newHttpClient();
  11.         HttpRequest request = HttpRequest.newBuilder()
  12.                 .uri(URI.create("https://api.example.com/data"))
  13.                 .GET()
  14.                 .build();
  17.         // 發(fā)送異步請(qǐng)求
  18.         CompletableFuture<HttpResponse<String>> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
  21.         // 處理異步響應(yīng)
  22.         future.thenAccept(response -> {
  23.             System.out.println("Response code: " + response.statusCode());
  24.             System.out.println("Response body: " + response.body());
  25.         });
  28.         // 阻塞主線程，等待異步請(qǐng)求完成
  29.         future.join();
  30.     }
  31. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中數(shù)據(jù)化的 HTTP Client API，通過(guò) CompletableFuture 實(shí)現(xiàn)異步發(fā)送 HTTP 請(qǐng)求，并處理異步響應(yīng)。

15. JEP 443: 新的注釋 API

JDK 21 引入了 JEP 443，該功能提供了新的注釋 API，使得開(kāi)發(fā)者能夠更方便地操作和處理 Java 源代碼中的注釋信息。

示例代碼：

  1. import java.lang.annotation.*;
  2. import java.lang.reflect.*;
  5. @Retention(RetentionPolicy.RUNTIME)
  6. @interface MyAnnotation {
  7.     String value();
  8. }
  11. public class Example {
  12.     @MyAnnotation("Example annotation")
  13.     public void myMethod() {
  14.         // Method body
  15.     }
  18.     public static void main(String[] args) throws Exception {
  19.         Method method = Example.class.getMethod("myMethod");
  20.         MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
  23.         if (annotation != null) {
  24.             System.out.println("Annotation value: " + annotation.value());
  25.         } else {
  26.             System.out.println("Annotation not found");
  27.         }
  28.     }
  29. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中新的注釋 API，通過(guò)反射獲取方法上的注解信息并進(jìn)行處理。

16. JEP 445: 向量 API（Incubator）

JDK 21 引入了 JEP 445，該功能為 Java 增加了向量 API，使得開(kāi)發(fā)者能夠更高效地進(jìn)行向量化操作，從而提升代碼的性能。

示例代碼：

  1. import jdk.incubator.vector.*;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         VectorSpecies<Float> species = FloatVector.SPECIES_256;
  7.         float[] a = new float[species.length()];
  8.         float[] b = new float[species.length()];
  11.         // 初始化數(shù)組
  12.         for (int i = 0; i < species.length(); i++) {
  13.             a[i] = i;
  14.             b[i] = i * 2;
  15.         }
  18.         // 使用向量化操作進(jìn)行數(shù)組加法
  19.         FloatVector va = FloatVector.fromArray(species, a, 0);
  20.         FloatVector vb = FloatVector.fromArray(species, b, 0);
  21.         FloatVector result = va.add(vb);
  24.         // 將結(jié)果寫(xiě)回?cái)?shù)組
  25.         result.intoArray(a, 0);
  28.         // 打印結(jié)果數(shù)組
  29.         for (float f : a) {
  30.             System.out.println(f);
  31.         }
  32.     }
  33. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的向量 API 進(jìn)行數(shù)組加法操作，通過(guò)向量化操作實(shí)現(xiàn)更高效的計(jì)算。

17. JEP 451: 增強(qiáng)的 Thread API

JDK 21 引入了 JEP 451，該功能增強(qiáng)了 Thread API，使得開(kāi)發(fā)者能夠更方便地管理和操作線程。

示例代碼：

  1. public class Example {
  2.     public static void main(String[] args) {
  3.         // 創(chuàng)建一個(gè)新的線程
  4.         Thread thread = new Thread(() -> {
  5.             System.out.println("Thread is running...");
  6.             try {
  7.                 Thread.sleep(2000);
  8.             } catch (InterruptedException e) {
  9.                 e.printStackTrace();
  10.             }
  11.             System.out.println("Thread finished.");
  12.         });
  15.         // 設(shè)置線程名稱
  16.         thread.setName("MyThread");
  19.         // 啟動(dòng)線程
  20.         thread.start();
  23.         // 等待線程結(jié)束
  24.         try {
  25.             thread.join();
  26.         } catch (InterruptedException e) {
  27.             e.printStackTrace();
  28.         }
  31.         System.out.println("Main thread finished.");
  32.     }
  33. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中增強(qiáng)的 Thread API，包括設(shè)置線程名稱、等待線程結(jié)束等操作，使得開(kāi)發(fā)者能夠更方便地管理和操作線程。

18. JEP 457: 改進(jìn)的 JVM 垃圾收集器

JDK 21 引入了 JEP 457，該功能改進(jìn)了 JVM 的垃圾收集器，使得其能夠更高效地管理內(nèi)存，提升應(yīng)用程序的性能和穩(wěn)定性。

示例代碼：

  1. public class Example {
  2.     public static void main(String[] args) {
  3.         // 創(chuàng)建大量對(duì)象，觸發(fā)垃圾收集器
  4.         for (int i = 0; i < 1000000; i++) {
  5.             Object obj = new Object();
  6.         }
  7.     }
  8. }

解釋：上面的示例代碼展示了如何創(chuàng)建大量對(duì)象以觸發(fā) JVM 的垃圾收集器，通過(guò) JEP 457 改進(jìn)的垃圾收集器，可以更高效地管理這些對(duì)象，減少內(nèi)存泄漏和性能問(wèn)題。

19. JEP 468: 改進(jìn)的線程安全性

JDK 21 引入了 JEP 468，該功能改進(jìn)了 Java 中的線程安全性，使得開(kāi)發(fā)者能夠更安全地在多線程環(huán)境中編寫(xiě)并發(fā)程序。

示例代碼：

  1. import java.util.concurrent.atomic.AtomicInteger;
  4. public class Example {
  5.     private static AtomicInteger count = new AtomicInteger(0);
  8.     public static void main(String[] args) throws InterruptedException {
  9.         // 創(chuàng)建多個(gè)線程對(duì)計(jì)數(shù)器進(jìn)行操作
  10.         for (int i = 0; i < 10; i++) {
  11.             Thread thread = new Thread(() -> {
  12.                 for (int j = 0; j < 1000; j++) {
  13.                     count.incrementAndGet();
  14.                 }
  15.             });
  16.             thread.start();
  17.         }
  20.         // 等待所有線程結(jié)束
  21.         Thread.sleep(1000);
  24.         // 打印計(jì)數(shù)器的值
  25.         System.out.println("Count: " + count);
  26.     }
  27. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的原子操作類 AtomicInteger 來(lái)確保在多線程環(huán)境中對(duì)計(jì)數(shù)器的安全操作，通過(guò) JEP 468 改進(jìn)的線程安全性，可以避免出現(xiàn)競(jìng)態(tài)條件和數(shù)據(jù)不一致的問(wèn)題。

20. JEP 390: 基于Java命令行工具的包管理工具

JDK 21 引入了 JEP 390，該功能提供了基于 Java 命令行工具的包管理工具，使得開(kāi)發(fā)者能夠更方便地管理和使用第三方庫(kù)。

示例代碼：

  1. ## 在命令行中使用 jpm 安裝第三方庫(kù)
  2. jpm install example-library

解釋：上面的示例代碼展示了如何使用 JDK 21 中的包管理工具 jpm 來(lái)安裝第三方庫(kù)，使得開(kāi)發(fā)者能夠更方便地在項(xiàng)目中引入外部依賴。

21. JEP 395: 基于文本的 UI 工具包

JDK 21 引入了 JEP 395，該功能提供了基于文本的 UI 工具包，使得開(kāi)發(fā)者能夠更輕松地創(chuàng)建命令行界面的用戶界面。

示例代碼：

  1. import java.io.Console;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         Console console = System.console();
  7.         if (console != null) {
  8.             console.printf("Enter your name: ");
  9.             String name = console.readLine();
  10.             console.printf("Hello, %s!\n", name);
  11.         } else {
  12.             System.err.println("No console available");
  13.         }
  14.     }
  15. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中基于文本的 UI 工具包來(lái)創(chuàng)建一個(gè)簡(jiǎn)單的命令行界面，使得開(kāi)發(fā)者能夠更方便地與用戶進(jìn)行交互。

22. JEP 423: 在編譯時(shí)檢查動(dòng)態(tài)生成的代碼

JDK 21 引入了 JEP 423，該功能使得在編譯時(shí)能夠檢查動(dòng)態(tài)生成的代碼，從而提前發(fā)現(xiàn)潛在的錯(cuò)誤。

示例代碼：

  1. public class Example {
  2.     public static void main(String[] args) {
  3.         String code = """
  4.                       public class GeneratedClass {
  5.                           public void sayHello() {
  6.                               System.out.println("Hello, world!");
  7.                           }
  8.                       }
  9.                       """;
  12.         // 編譯動(dòng)態(tài)生成的代碼
  13.         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
  14.         int result = compiler.run(null, null, null, code);
  17.         // 如果編譯成功，則加載并執(zhí)行動(dòng)態(tài)生成的類
  18.         if (result == 0) {
  19.             try {
  20.                 Class<?> clazz = Class.forName("GeneratedClass");
  21.                 Object obj = clazz.getDeclaredConstructor().newInstance();
  22.                 clazz.getMethod("sayHello").invoke(obj);
  23.             } catch (Exception e) {
  24.                 e.printStackTrace();
  25.             }
  26.         } else {
  27.             System.err.println("Compilation failed");
  28.         }
  29.     }
  30. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的編譯器 API，在運(yùn)行時(shí)動(dòng)態(tài)生成代碼并在編譯時(shí)進(jìn)行檢查，從而提前發(fā)現(xiàn)代碼中的錯(cuò)誤。

23. JEP 396: 強(qiáng)大的打印和日志工具

JDK 21 引入了 JEP 396，該功能提供了強(qiáng)大的打印和日志工具，使得開(kāi)發(fā)者能夠更方便地輸出調(diào)試信息和記錄日志。

示例代碼：

  1. import java.util.logging.*;
  4. public class Example {
  5.     private static final Logger logger = Logger.getLogger(Example.class.getName());
  8.     public static void main(String[] args) {
  9.         logger.info("This is an informational message");
  10.         logger.warning("This is a warning message");
  11.         logger.severe("This is a severe message");
  12.     }
  13. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中強(qiáng)大的日志工具，通過(guò) Logger 類來(lái)輸出不同級(jí)別的日志信息，使得開(kāi)發(fā)者能夠更方便地進(jìn)行調(diào)試和日志記錄。

24. JEP 397: Unix 套接字通道

JDK 21 引入了 JEP 397，該功能提供了 Unix 套接字通道，使得 Java 應(yīng)用程序能夠更輕松地與本地系統(tǒng)進(jìn)行通信。

示例代碼：

  1. import java.io.*;
  2. import java.net.*;
  3. import java.nio.file.*;
  6. public class Example {
  7.     public static void main(String[] args) throws IOException {
  8.         // 創(chuàng)建 Unix 套接字通道
  9.         Path socketFile = Paths.get("/tmp/mysocket");
  10.         UnixDomainSocketAddress address = UnixDomainSocketAddress.of(socketFile);
  11.         try (UnixDomainSocketChannel channel = UnixDomainSocketChannel.open(address)) {
  12.             // 發(fā)送數(shù)據(jù)
  13.             String message = "Hello, Unix socket!";
  14.             channel.write(ByteBuffer.wrap(message.getBytes()));
  17.             // 讀取響應(yīng)
  18.             ByteBuffer buffer = ByteBuffer.allocate(1024);
  19.             int bytesRead = channel.read(buffer);
  20.             buffer.flip();
  21.             byte[] responseBytes = new byte[bytesRead];
  22.             buffer.get(responseBytes);
  23.             String response = new String(responseBytes);
  24.             System.out.println("Response: " + response);
  25.         }
  26.     }
  27. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的 Unix 套接字通道來(lái)進(jìn)行進(jìn)程間通信，這使得 Java 應(yīng)用程序能夠更加靈活地與本地系統(tǒng)進(jìn)行交互。

25. JEP 398: 統(tǒng)一垃圾收集策略

JDK 21 引入了 JEP 398，該功能提供了統(tǒng)一的垃圾收集策略，使得開(kāi)發(fā)者能夠更方便地配置和管理垃圾收集器。

示例代碼：

  1. ## 啟動(dòng) Java 應(yīng)用程序時(shí)通過(guò)參數(shù)配置統(tǒng)一的垃圾收集策略
  2. java -XX:+UseZGC -jar myapp.jar

解釋：上面的示例代碼展示了如何使用 JDK 21 中的統(tǒng)一垃圾收集策略，在啟動(dòng) Java 應(yīng)用程序時(shí)通過(guò)參數(shù)來(lái)選擇合適的垃圾收集器，從而優(yōu)化應(yīng)用程序的性能和內(nèi)存管理。

26. JEP 400: JDK生態(tài)系統(tǒng)更新

JDK 21 引入了 JEP 400，該功能提供了 JDK 生態(tài)系統(tǒng)的更新機(jī)制，使得開(kāi)發(fā)者能夠更方便地獲取和應(yīng)用 JDK 生態(tài)系統(tǒng)的更新。

示例代碼：

  1. ## 使用 jpackage 工具打包 Java 應(yīng)用程序并包含 JDK 生態(tài)系統(tǒng)的更新
  2. jpackage --type app-image --name MyApp --input target/classes --main-jar myapp.jar --main-class com.example.MyApp --runtime-image /path/to/jdk21 --app-version 1.0

解釋：上面的示例代碼展示了如何使用 JDK 21 中的 jpackage 工具打包 Java 應(yīng)用程序，并在打包過(guò)程中包含 JDK 生態(tài)系統(tǒng)的更新，從而使得應(yīng)用程序能夠直接獲取更新的 JDK 生態(tài)系統(tǒng)。

27. JEP 401: 基于容器的發(fā)布

JDK 21 引入了 JEP 401，該功能提供了基于容器的發(fā)布機(jī)制，使得開(kāi)發(fā)者能夠更方便地將 Java 應(yīng)用程序打包成容器鏡像并進(jìn)行部署。

示例代碼：

  1. ## 使用 jlink 工具創(chuàng)建輕量級(jí)的運(yùn)行時(shí)鏡像
  2. jlink --output my-runtime-image --add-modules java.base,java.logging,java.xml
  5. ## 使用 jpackage 工具打包 Java 應(yīng)用程序并包含運(yùn)行時(shí)鏡像
  6. jpackage --type image --name MyApp --input target/classes --main-jar myapp.jar --main-class com.example.MyApp --runtime-image my-runtime-image --app-version 1.0
  9. ## 構(gòu)建容器鏡像
  10. docker build -t myapp .
  13. ## 運(yùn)行容器
  14. docker run -it --rm myapp

解釋：上面的示例代碼展示了如何使用 JDK 21 中的 jlink 和 jpackage 工具創(chuàng)建輕量級(jí)的運(yùn)行時(shí)鏡像，并將 Java 應(yīng)用程序打包成容器鏡像進(jìn)行部署。

28. JEP 404: ZGC on macOS

JDK 21 引入了 JEP 404，該功能為 macOS 系統(tǒng)提供了 Z Garbage Collector（ZGC），使得開(kāi)發(fā)者能夠在 macOS 平臺(tái)上使用低延遲的垃圾收集器。

示例代碼：

  1. ## 啟用 ZGC 垃圾收集器運(yùn)行 Java 應(yīng)用程序
  2. java -XX:+UseZGC -jar myapp.jar

解釋：上面的示例代碼展示了如何在 macOS 系統(tǒng)上啟用 ZGC 垃圾收集器來(lái)運(yùn)行 Java 應(yīng)用程序，從而實(shí)現(xiàn)低延遲和高吞吐量的垃圾收集。

29. JEP 407: 提高 Java 安全性

JDK 21 引入了 JEP 407，該功能提高了 Java 的安全性，包括修復(fù)了一些安全漏洞和弱點(diǎn)，并增強(qiáng)了安全特性。

示例代碼：

  1. public class Example {
  2.     public static void main(String[] args) {
  3.         // 安全地處理用戶輸入
  4.         String userInput = args[0];
  5.         String sanitizedInput = sanitize(userInput);
  6.         // 繼續(xù)處理經(jīng)過(guò)安全處理的用戶輸入
  7.     }
  10.     private static String sanitize(String input) {
  11.         // 進(jìn)行輸入驗(yàn)證和過(guò)濾，確保不包含惡意代碼
  12.         // 返回經(jīng)過(guò)安全處理的輸入
  13.         return input.replaceAll("<", "").replaceAll(">", "");
  14.     }
  15. }

解釋：上面的示例代碼展示了如何在 Java 應(yīng)用程序中安全地處理用戶輸入，通過(guò)輸入驗(yàn)證和過(guò)濾來(lái)防止惡意代碼的注入，提高應(yīng)用程序的安全性。

30. JEP 409: 應(yīng)用程序類數(shù)據(jù)共享

JDK 21 引入了 JEP 409，該功能提供了應(yīng)用程序類數(shù)據(jù)共享（AppCDS），使得多個(gè) Java 應(yīng)用程序能夠共享同一份類數(shù)據(jù)，減少內(nèi)存占用和啟動(dòng)時(shí)間。

示例代碼：

  1. ## 使用 jlink 工具創(chuàng)建包含應(yīng)用程序類數(shù)據(jù)共享的運(yùn)行時(shí)鏡像
  2. jlink --output my-runtime-image --add-modules java.base,java.logging,java.xml --class-for-name com.example.MyClass
  5. ## 使用 jpackage 工具打包 Java 應(yīng)用程序并包含運(yùn)行時(shí)鏡像
  6. jpackage --type image --name MyApp --input target/classes --main-jar myapp.jar --main-class com.example.MyApp --runtime-image my-runtime-image --app-version 1.0

解釋：上面的示例代碼展示了如何使用 JDK 21 中的 jlink 工具創(chuàng)建包含應(yīng)用程序類數(shù)據(jù)共享的運(yùn)行時(shí)鏡像，并使用 jpackage 工具打包 Java 應(yīng)用程序，從而實(shí)現(xiàn)多個(gè)應(yīng)用程序共享同一份類數(shù)據(jù)，減少內(nèi)存占用和啟動(dòng)時(shí)間。

31. JEP 412: 在 Windows 平臺(tái)上啟用 AOT 編譯

JDK 21 引入了 JEP 412，該功能在 Windows 平臺(tái)上啟用了 AOT（Ahead-of-Time）編譯器，使得開(kāi)發(fā)者能夠?qū)?Java 應(yīng)用程序編譯成本地機(jī)器代碼，提高應(yīng)用程序的性能。

示例代碼：

  1. ## 使用 jaotc 工具將 Java 應(yīng)用程序編譯成本地機(jī)器代碼
  2. jaotc --output myapp.dll --module mymodule

解釋：上面的示例代碼展示了如何使用 JDK 21 中的 jaotc 工具將 Java 應(yīng)用程序編譯成本地機(jī)器代碼，從而提高應(yīng)用程序的性能。

32. JEP 414: 向量API v2.0（Incubator）

JDK 21 引入了 JEP 414，該功能為向量API提供了第二個(gè)版本，包括更多的操作和改進(jìn)，使得開(kāi)發(fā)者能夠更高效地利用硬件向量化指令。

示例代碼：

  1. import jdk.incubator.vector.*;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         VectorSpecies<Float> species = FloatVector.SPECIES_256;
  7.         float[] a = new float[species.length()];
  8.         float[] b = new float[species.length()];
  11.         // 初始化數(shù)組
  12.         for (int i = 0; i < species.length(); i++) {
  13.             a[i] = i;
  14.             b[i] = i * 2;
  15.         }
  18.         // 使用向量化操作進(jìn)行數(shù)組加法
  19.         FloatVector va = FloatVector.fromArray(species, a, 0);
  20.         FloatVector vb = FloatVector.fromArray(species, b, 0);
  21.         FloatVector result = va.add(vb);
  24.         // 將結(jié)果寫(xiě)回?cái)?shù)組
  25.         result.intoArray(a, 0);
  28.         // 打印結(jié)果數(shù)組
  29.         for (float f : a) {
  30.             System.out.println(f);
  31.         }
  32.     }
  33. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的向量API v2.0進(jìn)行數(shù)組加法操作，通過(guò)向量化操作實(shí)現(xiàn)更高效的計(jì)算。

33. JEP 416: 改進(jìn)的 AArch64 程序計(jì)數(shù)器模型

JDK 21 引入了 JEP 416，該功能提供了改進(jìn)的 AArch64（ARM 64位架構(gòu)）程序計(jì)數(shù)器模型，使得在 ARM 64位架構(gòu)上的 Java 應(yīng)用程序能夠更好地執(zhí)行和調(diào)試。

示例代碼：

  1. ## 編譯和運(yùn)行 Java 應(yīng)用程序
  2. javac MyApp.java
  3. java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly MyApp

解釋：上面的示例代碼展示了如何使用 JDK 21 在 ARM 64位架構(gòu)上編譯和運(yùn)行 Java 應(yīng)用程序，并使用診斷選項(xiàng)和打印匯編輸出來(lái)調(diào)試程序執(zhí)行情況。

34. JEP 419: Unix 套接字通道 API v2

JDK 21 引入了 JEP 419，該功能提供了 Unix 套接字通道 API 的第二個(gè)版本，包括更多的操作和改進(jìn)，使得開(kāi)發(fā)者能夠更靈活地在 Unix 系統(tǒng)上進(jìn)行進(jìn)程間通信。

示例代碼：

  1. import java.io.IOException;
  2. import java.net.SocketAddress;
  3. import java.nio.channels.*;
  6. public class Example {
  7.     public static void main(String[] args) throws IOException {
  8.         try (UnixDomainSocketChannel channel = UnixDomainSocketChannel.open()) {
  9.             // 連接到指定的 Unix 套接字地址
  10.             SocketAddress address = UnixDomainSocketAddress.of("/tmp/mysocket");
  11.             channel.connect(address);
  14.             // 發(fā)送數(shù)據(jù)
  15.             channel.write(ByteBuffer.wrap("Hello, Unix socket!".getBytes()));
  18.             // 讀取響應(yīng)
  19.             ByteBuffer buffer = ByteBuffer.allocate(1024);
  20.             int bytesRead = channel.read(buffer);
  21.             buffer.flip();
  22.             byte[] responseBytes = new byte[bytesRead];
  23.             buffer.get(responseBytes);
  24.             String response = new String(responseBytes);
  25.             System.out.println("Response: " + response);
  26.         }
  27.     }
  28. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的 Unix 套接字通道 API v2 進(jìn)行進(jìn)程間通信，包括連接到指定的 Unix 套接字地址、發(fā)送數(shù)據(jù)和讀取響應(yīng)等操作。

35. JEP 420: 簡(jiǎn)化的泛型參數(shù)名稱

JDK 21 引入了 JEP 420，該功能簡(jiǎn)化了泛型參數(shù)的命名規(guī)范，使得開(kāi)發(fā)者能夠更清晰地理解泛型類型和方法的含義。

示例代碼：

  1. import java.util.List;
  4. public class Example {
  5.     public static void main(String[] args) {
  6.         // 使用簡(jiǎn)化的泛型參數(shù)名稱
  7.         List<String> list = List.of("apple", "banana", "orange");
  8.         String first = list.get(0);
  9.         System.out.println("First element: " + first);
  10.     }
  11. }

解釋：上面的示例代碼展示了如何使用 JDK 21 中的簡(jiǎn)化泛型參數(shù)名稱特性，使得開(kāi)發(fā)者能夠更清晰地閱讀和理解泛型類型和方法的含義。

好了，以上是 V 哥在學(xué)習(xí) JDK21的過(guò)程中總結(jié)的35個(gè)新特性，有了這些新特性的加持，對(duì) Java 開(kāi)發(fā)的應(yīng)用在安全、穩(wěn)定、簡(jiǎn)化復(fù)雜代碼、構(gòu)建和部署、可靠性、并發(fā)、模塊化等方面，有了更好的支持。兄弟們，收藏起來(lái)慢慢學(xué)習(xí)，最后，V 哥想說(shuō)一句，整理不易，如果這篇內(nèi)容對(duì)你有幫助，也希望可以分享給更多學(xué)習(xí) Java 的小伙伴，你還知道 JDK21有哪些新特性嗎，V 哥歡迎留言分享給我，在此先謝過(guò)！JDK 21

以上內(nèi)容是否對(duì)您有幫助：
在線筆記
App下載
App下載

掃描二維碼

下載編程獅App

公眾號(hào)
微信公眾號(hào)

編程獅公眾號(hào)