Java 8

主要特性：

• Lambda, 函數式接口，方法引用，Optional, Stream的引入
• 接口默認方法，重復注解，日期API, Base64支持

Lambda和函數式接口

函數式接口就是有且僅有一個抽象方法，但是可以有多個非抽象方法的接口。可以隱式轉化為 Lambda 表達式。

@FunctionalInterface interface Operation {int operation(int a, int b); }class Test {private int operate(int a, int b, Operation operation) {return operation.operation(a, b);} }Test test = new Test(); test.operate(1, 2, (a, b) -> a + b);

方法引用

通過方法引用，可以使用方法的名字來指向一個方法。使用一對冒號來引 "::" 用方法。

構造方法引用

使用Class:new

Test test = Test.create(Test::new);

靜態方法引用

使用方式：Class::staticMethod

test.operate(1, 2, Test::add);

實例方法引用

使用方式：instance::method

test.operate(1, 2, test::sub);

接口默認方法

Java 8 新增了接口的默認實現，通過 default 關鍵字表示。

public interface TestInterface {// 接口默認方法default String test() {return "default";} }

重復注解

Java 8 支持了重復注解。在 Java 8 之前想實現重復注解，需要用一些方法來繞過限制。比如下面的代碼。

@interface Author {String name(); }@interface Authors {Author[] value(); }@Authors({@Author(name="a"), @Author(name = "b")}) class Article { }

而在 Java 8 中，可以直接用下面的方式。

@Repeatable(Authors.class) @interface Author {String name(); }@interface Authors {Author[] value(); }@Author(name = "a") @Author(name = "b") class Article { }

在解析注解的時候，Java 8 也提供了新的 API。

AnnotatedElement.getAnnotationsByType(Class<T>)

類型注解

Java 8 之前注解只能用在聲明中，在 Java 8 中，注解可以使用在 任何地方。

@Author(name="a") private Object name = ""; private String author = (@Author(name="a")String) name;

更好的類型推斷

Java 8 對于類型推斷做了改進。

比如在 Java 7 中下面的寫法：

List<String> stringList = new ArrayList<>(); stringList.add("A"); stringList.addAll(Arrays.<String>asList());

在 Java 8 中改進后的寫法，可以自動做類型推斷。

List<String> stringList = new ArrayList<>(); stringList.add("A"); stringList.addAll(Arrays.asList());

Optional

Java 8 中新增了 Optional 類用來解決空指針異常。Optional 是一個可以保存 null 的容器對象。通過 isPresent() 方法檢測值是否存在，通過 get() 方法返回對象。

// 創建一個 String 類型的容器 Optional<String> str = Optional.of("str"); // 值是否存在 boolean pre = str.isPresent(); // 值如果存在就調用 println 方法，這里傳入的是 println 的方法引用 str.ifPresent(System.out::println); // 獲取值 String res = str.get(); // 傳入空值 str = Optional.ofNullable(null); // 如果值存在，返回值，否則返回傳入的參數 res = str.orElse("aa"); str = Optional.of("str"); // 如果有值，對其調用映射函數得到返回值，對返回值進行 Optional 包裝并返回 res = str.map(s -> "aa" + s).get(); // 返回一個帶有映射函數的 Optional 對象 res = str.flatMap(s -> Optional.of(s + "bb")).flatMap(s -> Optional.of(s + "cc")).get();

Stream

Java 8 中新增的 Stream 類提供了一種新的數據處理方式。這種方式將元素集合看做一種流，在管道中傳輸，經過一系列處理節點，最終輸出結果。

List<String> list = Arrays.asList("maa", "a", "ab", "c"); list.stream().filter(s -> s.contains("a")).map(s -> s + "aa").sorted().forEach(System.out::println);System.out.println("####"); list.parallelStream().forEach(System.out::println);List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); int res = numbers.stream().map(i -> i + 1).mapToInt(i -> i).summaryStatistics().getMax(); System.out.println(res);

日期時間API

Java 8 中新增了日期時間 API 用來加強對日期時間的處理，其中包括了 LocalDate，LocalTime，LocalDateTime，ZonedDateTime 等等，關于 API 可以參照官方文檔以及這篇博客，寫的很詳細。下面是示例代碼。

LocalDate now = LocalDate.now(); System.out.println(now); System.out.println(now.getYear()); System.out.println(now.getMonth()); System.out.println(now.getDayOfMonth());LocalTime localTime = LocalTime.now(); System.out.println(localTime); LocalDateTime localDateTime = now.atTime(localTime); System.out.println(localDateTime);

Base64支持

Java 8 標準庫中提供了對 Base 64 編碼的支持。具體 API 見可參照文檔。下面是示例代碼。

String base64 = Base64.getEncoder().encodeToString("aaa".getBytes()); System.out.println(base64); byte[] bytes = Base64.getDecoder().decode(base64); System.out.println(new String(bytes));

并行數組ParallelSort

Java 8 中提供了對數組的并行操作，包括 parallelSort 等等，具體可參照 API。

Arrays.parallelSort(new int[] {1, 2, 3, 4, 5});

Java 11

主要特性：

• 接口私有方法、集合不可變工廠方法、局部類型推斷
• 改進try-with-resource, String底層數據結構變更，字符串增強，鉆石操作符增強，Stream, Optional增強
• G1稱為默認收集器，G1并行full gc，引入ZGC, Epsilon, Graal垃圾收集器

接口中使用私有方法

Java 9 中可以在接口中定義私有方法。示例代碼如下：

public interface TestInterface {String test();// 接口默認方法default String defaultTest() {pmethod();return "default";}private String pmethod() {System.out.println("private method in interface");return "private";} }

集合不可變實例工廠方法

在以前，我們想要創建一個不可變的集合，需要先創建一個可變集合，然后使用 unmodifiableSet 創建不可變集合。代碼如下：

Set<String> set = new HashSet<>(); set.add("A"); set.add("B"); set.add("C");set = Collections.unmodifiableSet(set); System.out.println(set);

Java 9 中提供了新的 API 用來創建不可變集合。

List<String> list = List.of("A", "B", "C"); Set<String> set = Set.of("A", "B", "C"); Map<String, String> map = Map.of("KA", "VA", "KB", "VB");

新增局部類型推斷 var

var關鍵字用于局部變量, for循環，lambda表達式中

局部變量及for循環(10)

var a = "aa"; System.out.println(a);

lambda(11)

(var x, var y) -> x.process(y)

改進 try-with-resources

Java 9 中不需要在 try 中額外定義一個變量。Java 9 之前需要這樣使用 try-with-resources：

InputStream inputStream = new StringBufferInputStream("a"); try (InputStream in = inputStream) {in.read(); } catch (IOException e) {e.printStackTrace(); }

在 Java 9 中可以直接使用 inputStream 變量，不需要再額外定義新的變量了。

InputStream inputStream = new StringBufferInputStream("a"); try (inputStream) {inputStream.read(); } catch (IOException e) {e.printStackTrace(); }

String 底層存儲結構發生變化使用字節數組

字符串 API 增強

Java 11 新增了 一系列字符串處理方法，例如：

// 判斷字符串是否為空白 " ".isBlank(); " Javastack ".stripTrailing(); // " Javastack" " Javastack ".stripLeading(); // "Javastack "

增強了鉆石操作符 "<>"，可以在 匿名內部類中使用了。

在 Java 9 之前，內部匿名類需要指定泛型類型，如下：

Handler<? extends Number> intHandler1 = new Handler<Number>(2) { }

而在 Java 9 中，可以自動做類型推導，如下：

Handler<? extends Number> intHandler1 = new Handler<>(2) { }

增強了 Stream，Optional，Process API

takeWhile 從Stream中依次獲取滿足條件的元素，直匹配到一個不滿足條件為止結束獲取，不同與filter

List<Integer> list = List.of(11,33,44,102,232,454,67,556,46,78); list.stream().takeWhile(x -> x < 100).forEach(System.out::println); // 輸出結果如下 11 33 44

dropWhile 從Stream中依次刪除滿足條件的元素，直到匹配到一個不滿足條件為止結束刪除

List<Integer> list = List.of(11,33,44,102,232,454,67,556,46,78); list.stream().dropWhile(x -> x < 100).forEach(System.out::println); // 輸出結果如下 102 232 454 67 556 46 78

新增Stream.ofNullable(null) 允許單一的null元素

Stream.iterate重載方法

Stream.iterate(0, k -> k + 1).limit(12).forEach(System.out::println); // 9 新增的重載方法 Stream.iterate(0, k -> k < 12, k -> k + 1).forEach(System.out::println);

Optional新增元素轉化為stream方法等

Optional.of(List.of(1, 23, 4, 5, 6)).stream().forEach(System.out::println);

新增方法orElseThrow和ifPresentOrElse。

首先是orElseThrow，如果沒有值，則使用該orElseThrow方法拋出NoSuchElementException。否則，它返回一個值。

public Person getPersonById(Long id) {Optional<Person> personOpt = repository.findById(id);return personOpt.orElseThrow(); }

第二種有趣的方法是ifPresentOrElse。如果存在一個值，它將使用該值執行給定的操作。否則，它將執行給定的基于空的操作。

public void printPersonById(Long id) {Optional<Person> personOpt = repository.findById(id);personOpt.ifPresentOrElse(System.out::println,() -> System.out.println("Person not found")); }

模塊化

什么是模塊？

官方對模塊的定義為：一個被命名的，代碼和數據的自描述集合。（ the module, which is a named, self-describing collection of code and data）。

為什么模塊化？

顯示依賴管理：每個模塊需要顯式聲明自己需暴露的包，而自己所依賴的和自己內部使用的包，則不會暴露，也不會被外部引用到，大大的減少Jar包沖突的情況。

強封裝性：模塊顯示選擇向其他模塊只暴露需要的類或者接口，而完美隱藏了內部實現細節及其內部成員，實現真正的封裝性。

安全性：顯式依賴管理及強封裝性，大大的減少了程序運行時不必要模塊的加載，減少了Java運行期間的被攻擊面。

規范性：顯示的聲明暴露的內容，可以讓第三方庫的開發者更好的管理自己的內部實現邏輯和內部類。第三方庫作者可以更輕松的管理自己的內部類的訪問權限和反射調用權限，避免了出現sun.misc.BASE64Encoder這些內部類在已經被官方聲明了過時和不建議使用的前提下，仍有大量的開發者去隨意使用的情況。

自定義最小運行時映射：Java因為其向后兼容的原則，不會輕易對其內容進行刪除，包含的陳舊過時的技術也越來越多，導致JDK變得越來越臃腫。而Java9的顯示依賴管理使得加載最小所需模塊成為了可能，我們可以選擇只加載必須的JDK模塊，拋棄如java.awt, javax.swing, java.applet等這些用不到的模塊。這種機制，大大的減少了運行Java環境所需要的內存資源，在對于嵌入式系統開發或其他硬件資源受限的場景下的開發非常有用。

制作最小運行時映像：

使用jlink工具來創建最小運行時映像。以下是一個示例命令，其中$JAVA_HOME變量引用了您安裝的Java 9 JDK的根目錄，并將最小運行時映像創建在myimage目錄中：

$ $JAVA_HOME/bin/jlink --module-path $JAVA_HOME/jmods --add-modules $modules --output myimage

請注意，上面的命令假定您的模塊列表已保存在名為modules的變量中。如果您沒有將模塊列表保存到變量中，請在上面的命令中將$modules替換為逗號分隔的模塊列表。

運行最小運行時映像。以下是一個示例命令，其中$JAVA_HOME變量引用了您安裝的Java 9 JDK的根目錄，并且myimage目錄包含了您創建的最小運行時映像：

$ myimage/bin/java --list-modules

上面的命令將列出您的最小運行時映像中包含的模塊。

怎么模塊化？

/x1/java/jdk11/jmods$ ../bin/jmod describe java.logging.jmod java.logging@11 exports java.util.logging requires java.base mandated provides jdk.internal.logger.DefaultLoggerFinder with sun.util.logging.internal.LoggingProviderImpl contains sun.net.www.protocol.http.logging contains sun.util.logging.internal contains sun.util.logging.resources platform linux-amd64

requires 表示這個模塊需要依賴哪個包，base包是基礎肯定是需要依賴的

exports 表示這個模塊可以提供什么給其他模塊使用，這里定義了java.util.logging，就是日志模塊的主要對外暴露的功能

provides with 表示這個模塊提供了哪個Service能力，我們知道Java開發中經常使用ServiceLoader來加載只使用接口，而實現是通過聲明來提供的類。這里DefaultLoggerFinder就是接口，而LoggingProviderImpl就是實現類

contains 表示這個模塊中還有哪些類包，但并不對外暴露

platform 表示是linux amd6架構體系的

use 說明應用系統可以使用哪個Service接口

open 表示對外暴露的功能還允許通過反射訪問，很多開發框架都需要這個能力

模塊export對外暴露可以使用to關鍵字定向限定只有某一個模塊才可以訪問這個模塊

如果使用transitive關鍵字，表示可以傳遞對外暴露能力。

為了保證兼容性，除了正規的module（帶有module-info且位于module path下）之外，還有兩種特殊的module來為向后兼容或者說輔助遷移提供幫助。

Unnamed Module

每個classloader在classpath下加載的所有JAR（不管是否模塊化）共同組成一個unnamed module（未命名模塊），未命名模塊自動聲明依賴所有的顯式模塊，同時exports自己的所有包，而一個顯式模塊并不能聲明依賴未命名模塊。

Automatic Module

模塊系統會為在module path上找到的每個JAR包創建一個內部模塊，對于模塊化的JAR包來說，因為包含了module-info文件，它的模塊名、依賴、導出等都是有明確描述的，所以沒有什么問題。但是遷移的過程中無法避免非模塊化的JAR包依賴。這種情況下模塊系統會為它自動創建一個模塊，即Automatic module（自動模塊），并且對該模塊的屬性進行最安全的補全。

Name：對于模塊的名稱，如果在MANIFEST文件中定義了Automatic-module-name這個header則以此值為準，否則使用JAR包文件名。

Requires：模塊系統允許自動模塊讀取所有其他模塊，也就是說自動模塊依賴其他所有模塊。與其他顯式定義的正規模塊不同，自動模塊可以讀取未命名模塊。

Exports / Opens：模塊系統Export、Open Jar包內的所有package

多版本兼容 jar 包

多版本兼容 JAR 功能能讓你創建僅在特定版本的 Java 環境中運行庫程序時選擇使用的 class 版本。通過 --release 參數指定編譯版本。具體的變化就是 META-INF 目錄下 MANIFEST.MF 文件新增了一個屬性：

Multi-Release: true

然后 META-INF 目錄下還新增了一個 versions 目錄，如果是要支持 java9，則在 versions 目錄下有 9 的目錄。

multirelease.jar ├── META-INF │ └── versions │ └── 9 │ └── multirelease │ └── Helper.class ├── multirelease├── Helper.class└── Main.class

實例

創建文件夾 c:/test/java7/com/runoob，并在該文件夾下創建 Test.java 文件，代碼如下：

package com.runoob;public class Tester {public static void main(String[] args) {System.out.println("Inside java 7");} }

創建文件夾 c:/test/java9/com/runoob，并在該文件夾下創建 Test.java 文件，代碼如下：

package com.runoob;public class Tester {public static void main(String[] args) {System.out.println("Inside java 9");} }

編譯源代碼

C:\test > javac --release 9 java9/com/runoob/Tester.java C:\JAVA > javac --release 7 java7/com/runoob/Tester.java

創建多版本兼容 jar 包

C:\JAVA > jar -c -f test.jar -C java7 . --release 9 -C java9 . Warning: entry META-INF/versions/9/com/runoob/Tester.java, multiple resources with same name

使用 JDK 7 執行：

C:\JAVA > java -cp test.jar com.runoob.Tester Inside Java 7

使用 JDK 9 執行：

C:\JAVA > java -cp test.jar com.runoob.Tester Inside Java 9

G1 成為默認垃圾收集器（Jdk9）

在 Java 8 的時候，默認垃圾回收器是 Parallel Scavenge（新生代）+Parallel Old（老年代）。到了 Java 9, CMS 垃圾回收器被廢棄了，G1（Garbage-First Garbage Collector） 成為了默認垃圾回收器。G1 是在 Java 7 中被引入的，經過兩個版本優異的表現成為成為默認垃圾回收器。

HTTP Client

在 JDK 11 中 Http Client API 得到了標準化的支持。且支持 HTTP/1.1 和 HTTP/2 ，也支持 websockets。

使用起來也很簡單，如下：

HttpClient client = HttpClient.newHttpClient();HttpRequest request = HttpRequest.newBuilder().uri(URI.create(uri)).build();// 異步client.sendAsync(request, HttpResponse.BodyHandlers.ofString()).thenApply(HttpResponse::body).thenAccept(System.out::println).join();// 同步HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());System.out.println(response.body());

支持TLS 1.3 協議

實現TLS協議1.3版本, 替換了之前版本中包含的 TLS，包括 TLS 1.2，同時還改進了其他 TLS 功能, 在安全性和性能方面也做了很多提升

多線程并行 GC

在JDK9中G1被選定為默認的垃圾收集器，G1的設計目標是避免發生Full GC，由于Full GC較難產生所以在設計之初只有Young GC和Mixed GC是并行的，而Full GC是單線程使用標記-清理-合并算法進行垃圾回收。G1只是避免發生Full GC，在極端情況下，當G1的回收速度相對于產生垃圾的速度不是足夠快時，就會發生Full GC。

為了最大限度地減少 Full GC 造成的應用停頓的影響，從 JDK 10開始，G1 的 FullGC 改為并行的標記清除算法，同時會使用與年輕代回收和混合回收相同的并行工作線程數量，從而減少了 Full GC 的發生，以帶來更好的性能提升、更大的吞吐量

線程的數量可以由?-XX:ParallelGCThreads?選項來控制，這個參數也用來控制Young GC和Mixed GC的線程數。

引入了實驗性的ZGC以及Epsilon垃圾回收器

基于Java的實驗性JIT編譯器Graal

Graal 是一個以 Java 為主要編程語言，面向 Java bytecode 的編譯器。與用 C++ 實現的 C1 及 C2 相比，它的模塊化更加明顯，也更加容易維護。Graal 既可以作為動態編譯器，在運行時編譯熱點方法；亦可以作為靜態編譯器，實現 AOT 編譯。在 JDK 10 中，Graal 作為試驗性 JIT compiler 一同發布

java 命令直接編譯并運行 java 文件，省去先 javac 編譯生成 class 再運行的步驟

以前編譯一個 java 文件時，需要先 javac 編譯為 class，然后再用 java 執行，現在可以放到一起執行了，香啊！

$ java HelloWorld.java Hello Java 11!

JShell REPL

Java 9 提供了交互式解釋器。有了 JShell 以后，Java 終于可以像 Python，Node.js 一樣在 Shell 中運行一些代碼并直接得出結果了。

Java 17

主要特性：

• 增強switch表達式, instance of，文本塊支持
• 新增Record類，Sealed類，隱藏類
• 移除CMS, G1收集器優化，ZGC, Shenandoah成為正式版

switch 表達式

Java 12 以后，switch 不僅可以作為語句，也可以作為表達式。可以定義多個case標簽并使用箭頭返回值。

private String switchTest(int i) {return switch (i) {case 1 -> "1";default -> "0";}; }

也可以寫邏輯，然后返回(13)

int j = newSwitch (day) {case 1, 2, 3 -> "摸魚工作日"; case 4 -> "小周五";case 5, 6, 7 -> "休息日";default -> {var k = day.toString().length();var res = f(k);yield res;} };

instanceof + 類型強轉一步到位

之前處理動態類型碰上要強轉時，需要先 instanceof 判斷一下，然后再強轉為該類型處理：

Object obj = "Hello Java 12!"; if (obj instanceof String) {String s = (String) obj;int length = s.length(); }

現在 instanceof 支持直接類型轉換了，不需要再來一次額外的強轉：

Object obj = "Hello Java 12!"; if (obj instanceof String str) {int length = str.length(); }

文本塊（Text Block）的支持

??文本塊是多行字符串文字，它避免使用轉義序列，并以可預測的方式自動設置字符串格式。它還使開發人員可以控制字符串的格式。從Java 13開始，文本塊可用作預覽功能。它們以三個雙引號（"""）開頭。讓我們看看我們如何輕松地創建和格式化JSON消息。

public String getNewPrettyPrintJson() {return """{"name": "chenhaha","sex": "undefined"}"""; }

新增 Record 類

從Java 14開始，引入了新的Record類。我們定義Record類時，使用關鍵字record；

使用Records可以定義不可變的純數據類（僅限getter），也叫記錄類。它會自動創建toString，equals和hashCode方法。實際上，只需要定義如下所示的字段即可。

public record Person(String name, int age) {}

具有類似功能的類如record包含字段，構造函數，getter和toString，equals以及hashCode方法。

public class PersonOld {private final String name;private final int age;public PersonOld(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public int getAge() {return age;}@Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;PersonOld personOld = (PersonOld) o;return age == personOld.age && name.equals(personOld.name);}@Overridepublic int hashCode() {return Objects.hash(name, age);}@Overridepublic String toString() {return "PersonOld{" +"name='" + name + '\'' +", age=" + age +'}';}}

封閉（Sealed）類

使用密封類功能，可以限制超類的使用。使用new關鍵字，sealed可以定義哪些其他類或接口可以擴展或實現當前類。

public abstract sealed class Pet permits Cat, Dog {}

允許的子類必須定義一個修飾符。如果不想允許任何其他擴展名，則需要使用final關鍵字。

public final class Cat extends Pet {}

另一方面，你可以打開擴展類。在這種情況下，應使用non-sealed修飾符。

public non-sealed class Dog extends Pet {}

當然，下面的可見聲明是不允許的。

public final class Tiger extends Pet {}

隱藏類

標準 API 來定義無法發現且具有有限生命周期的隱藏類，從而提高 JVM 上所有語言的效率。JDK內部和外部的框架將能夠動態生成類，而這些類可以定義隱藏類。通常來說基于JVM的很多語言都有動態生成類的機制，這樣可以提高語言的靈活性和效率。

• 隱藏類天生為框架設計的，在運行時生成內部的class。
• 隱藏類只能通過反射訪問，不能直接被其他類的字節碼訪問。
• 隱藏類可以獨立于其他類加載、卸載，這可以減少框架的內存占用。

不能直接被其他class的二進制代碼使用的class。隱藏類主要被一些框架用來生成運行時類，但是這些類不是被用來直接使用的，而是通過反射機制來調用。

禁用、棄用偏向鎖

instanceof模式匹配、Record、jpackage打包工具開始正式使用

instanceof的模式匹配在JDK14作為preview，在JDK15作為第二輪的preview，在JDK16轉正

Record類型在JDK14作為preview，在JDK15處于第二輪preview，在JDK16轉正

jpackage在JDK14引入，JDK15作為incubating工具，在JDK16轉正，從

jdk.incubator.jpackage轉為jdk.jpackage。它支持Linux: deb and rpm、macOS: pkg and dmg、Windows: msi and exe

G1 收集器優化

JDK 12 為垃圾收集器 G1 帶來了兩項更新

• 可中止的混合收集集合：為了達到用戶提供的停頓時間目標，通過把要被回收的區域集（混合收集集合）拆分為強制和可選部分，使 G1 垃圾回收器能中止垃圾回收過程。G1 可以中止可選部分的回收以達到停頓時間目標。
• 及時返回未使用的已分配內存：由于 G1 盡量避免完整的 GC，并且僅基于 Java 堆占用和分配活動來觸發并發周期，因此在許多情況下，除非從外部強制執行，否則它不會返還 Java 堆內存。JDK 12增強了 G1 GC，可以在空閑時自動將 Java 堆內存返回給操作系統。

垃圾回收器（更新優化）

• 移除 CMS（Concurrent Mark Sweep）垃圾收集器
• ZGC優化window和mac
• 棄用 ParallelScavenge + SerialOld GC 組合

ZGC 和 Shenandoah 兩款垃圾回收器正式登陸

在 JAVA 15中，ZGC 和 Shenandoah 再也不是實驗功能，正式登陸了（不過 G1 仍然是默認的）。如果你升級到 JAVA 15 以后的版本，就趕快試試吧，性能更強，延遲更低。

新增 jpackage 打包工具

新增 jpackage 打包工具，直接打包二進制程序，再也不用裝 JRE 了！

之前如果想構建一個可執行的程序，還需要借助三方工具，將 JRE 一起打包，或者讓客戶電腦也裝一個 JRE 才可以運行我們的 JAVA 程序。

現在 JAVA 直接內置了 jpackage 打包工具，幫助你一鍵打包二進制程序包，不用再亂折騰了。

參考：

聊聊 Java8 以后各個版本的新特性 - 掘金

女同事問我JDK8以后有哪些新特性？給我整不會了__陳哈哈的博客-CSDN博客

Java9、10、11、12、13、14、15、16、17個版本新特性 - 簡書

升級指南之JDK 11+ 新特性和AJDK - 墨天輪

總結

以上是生活随笔為你收集整理的Java8 ~ Java17 新特性的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。