Java 和 JVM 自 JDK 8 至 21 的特性概览

引言

Java，这门自 1995 年诞生以来就广受欢迎的编程语言，以其跨平台的特性、强大的生态系统和稳定的性能表现，成为了软件开发领域的一个重要里程碑。随着时间的推移，Java 不断演进，以适应新的技术挑战和市场需求。自 JDK 8 发布以来，Java 平台经历了一系列重大的更新，每一次更新都为开发者带来了新的工具和能力，以构建更加高效、安全和现代化的应用程序。

Java 的历史和发展

从最初的 Java 1.0 到现在的 JDK 21，Java 语言和其运行环境 JVM（Java 虚拟机）已经走过了一段漫长的道路。Java 1.0 引入了最基本的面向对象编程概念，而随后的版本则不断扩展其功能，包括引入了泛型、注解、枚举类型等。JDK 5 和 JDK 8 是两个特别重要的版本，它们分别引入了自动装箱/拆箱和 Lambda 表达式，极大地简化了 Java 代码的编写。

JDK 8 至 21 的重要性

JDK 8 是一个转折点，它标志着 Java 进入了一个新的时代。这个版本引入了函数式编程的特性，使得 Java 开发者能够以更加声明式的方式编写并发和事件驱动的代码。随后的版本，如 JDK 11、JDK 14 和 JDK 16，都在不断地扩展和深化这些特性，同时引入了许多其他的改进，如模块系统、记录类和模式匹配等。JDK 21 继续这一趋势，带来了更多的语言和 API 改进，以及对 JVM 的优化。

本文的目的和结构

本文旨在为 Java 开发者提供一个全面的概览，介绍自 JDK 8 至 JDK 21 期间引入的所有重要特性。我们将按照特性的类型和用途进行分类，包括新语言特性、新 APIs、性能改进、安全增强、启动和打包工具的更新、Javadoc 和字节码的变更，以及新支持的平台和版本方案。此外，我们还将讨论那些已被弃用或移除的特性，以及这些变化对 Java 生态系统的长期影响。

通过本文，您将能够获得对 Java 最新特性的深入理解，无论您是 Java 新手还是经验丰富的开发者，都能从中获得宝贵的知识和见解。接下来，让我们开始探索 Java 自 JDK 8 以来的演变之旅。

新语言特性详细解析

模式匹配（Pattern Matching）

模式匹配是 Java 语言中一项革命性的新特性，它首次作为预览特性在 JDK 12 中引入，并在 JDK 16 中正式成为 Java 语言的一部分。这一特性借鉴了函数式编程语言中的模式匹配概念，允许开发者以一种更加简洁和表达性强的方式来检查和处理不同类型的数据。

模式匹配的引入背景

在模式匹配出现之前，Java 开发者通常使用if-else语句或者instanceof检查来处理不同类型的对象，这不仅使得代码变得冗长，而且可读性也较差。模式匹配的引入，为 Java 提供了一种新的、更加直观的方式来处理这些情况，特别是在处理复杂的对象结构时，它能够显著提高代码的清晰度和维护性。

模式匹配的具体用法

模式匹配在 Java 中的实现主要通过instanceof和switch表达式来完成。下面是一个使用模式匹配的简单例子：

  
Object obj = getSomeObject();  
  
if (obj instanceof String s) {  
    // 在这里可以直接使用变量 s，无需进行显式的类型转换  
    System.out.println("String length is " + s.length());  
} else if (obj instanceof Integer i) {  
    // 对于整型对象 i，可以直接进行数学运算  
    System.out.println("Integer value is " + i * 2);  
} else {  
    System.out.println("Unknown object type");  
}  

在上面的代码中，instanceof关键字后面紧跟着的是一个模式变量s或i，当obj的类型与模式匹配时，变量会被自动赋值，无需显式的类型转换。这种写法不仅简化了代码，还减少了出错的可能性。

模式匹配的优势和实例分析

模式匹配的优势在于它的简洁性和表达性。它允许开发者用更少的代码来表达更复杂的意思，并且使得代码的意图更加明确。此外，模式匹配还支持更复杂的结构，如嵌套的模式和守卫条件，这在处理复杂的数据结构时非常有用。

让我们来看一个更复杂的例子，其中使用了守卫条件和嵌套模式：

  
List<? extends Number> numbers = getNumbers();  
  
for (Number number : numbers) {  
    var absNumber = switch (number) {  
        case Integer i when i < 0 -> Math.abs(i);  
        case Integer i -> i;  
        case Double d -> Math.round(d);  
        default -> throw new IllegalArgumentException("Unsupported number type");  
    };  
    System.out.println(absNumber);  
}  

在这个例子中，我们使用了一个switch表达式来进行模式匹配。对于每种情况，我们都定义了一个模式，并在需要时使用守卫条件来进一步细化匹配的规则。这样，我们就能够根据不同的输入执行不同的操作，并且代码的结构依然保持清晰和简洁。

总的来说，模式匹配为 Java 带来了一种新的、强大的数据处理方式，它不仅提高了代码的可读性和可维护性，而且还使得 Java 语言更加现代化，更接近于其他流行的函数式编程语言。随着 Java 语言的不断发展，我们可以期待模式匹配在未来的 Java 版本中将发挥更加重要的作用。

未命名变量和未命名模式

在 Java 14 中，作为预览特性引入的未命名变量（也称为“var”类型）和未命名模式（也称为“模式变量”），为 Java 编程带来了新的表达性和灵活性。这些特性旨在简化代码，特别是在处理复杂的数据结构和流操作时，它们允许开发者忽略不需要的值，并提供了一种新的数据解构方式。

未命名变量的概念

未命名变量是 Java 中一种新的局部变量声明方式，它允许开发者声明一个变量而不需要预先指定其类型。这种变量的类型将由编译器根据赋值表达式自动推断。未命名变量通常与->操作符一起使用，后者在switch表达式中用于提供更复杂的逻辑分支。

未命名变量的使用场景

未命名变量特别适用于以下场景：

1. 当你只关心一个表达式的结果，而不打算在后续代码中使用变量时。
2. 当你需要从方法返回值中提取信息，但又不想显式声明所有组成部分时。
3. 在流操作中，当你需要处理流中的元素，但不需要存储任何中间变量时。

未命名模式的概念

未命名模式是模式匹配的一个扩展，它允许开发者在instanceof、case标签或catch块中声明一个模式变量，而不是一个具名变量。这在使用模式匹配解构复杂类型时非常有用，尤其是当你只需要访问类型的一部分数据时。

未命名模式的使用场景

未命名模式特别适用于以下场景：

1. 当你使用模式匹配来检查对象的类型，但不需要访问对象的具体实例时。
2. 在解构复杂对象时，当你只需要对象的某些部分，而不是整个对象时。

代码示例和实际应用

下面是一个使用未命名变量和未命名模式的示例：

  
// 使用未命名变量处理 Optional  
Optional<String> optStr = Optional.of("Hello");  
var str = optStr.orElse("Default");  
System.out.println(str); // 输出 "Hello"  
  
// 使用未命名变量在 try-catch 中忽略不需要的异常  
try {  
    // 可能会抛出 CheckedException 的代码  
} catch (Exception _) {  
    // 忽略异常，不进行处理  
}  
  
// 使用未命名模式在 switch 表达式中解构对象  
record Point(int x, int y) {}  
  
Point point = new Point(1, 2);  
switch (point) {  
    case Point(x) -> {  
        // 只关心 x 的值，y 的值被忽略  
        System.out.println("X coordinate is " + x);  
    }  
}  

在上述代码中，我们看到了未命名变量和未命名模式如何在不同场景下简化代码。未命名变量使得我们可以避免声明不必要的变量，而未命名模式则让我们能够更加灵活地处理复杂的数据结构。

总的来说，未命名变量和未命名模式是 Java 语言中两项非常有用的新特性，它们通过减少代码冗余和提高表达性，使得 Java 代码更加简洁和易于理解。随着这些特性在未来的 Java 版本中逐渐成熟和稳定，我们可以预见它们将在 Java 编程实践中发挥越来越重要的作用。

封闭类和记录类

随着 Java 语言不断发展，为了更好地支持函数式编程和数据建模，JDK 16 引入了两种新的类类型：封闭类（Sealed Classes）和记录类（Record Classes）。这些新特性旨在提供更丰富的类型安全保障和更简洁的代码表达，特别是在创建数据传输对象（DTOs）和限制继承结构时。

封闭类

封闭类是一种特殊的类，它限制了哪些其他类可以继承它。这一特性对于那些希望限制子类数量或者想要精确控制继承树的开发者来说非常有用。在 Java 中，封闭类通过sealed关键字进行声明，并且可以指定一个允许的子类列表。

封闭类的概念

封闭类的概念是为了在 Java 中引入更多的类型安全性和清晰性。它们允许开发者定义一个基类，同时限制哪些类可以扩展这个基类。这样做的好处是可以防止其他开发者创建不必要的或者不安全的子类，从而保护 API 的稳定性和可预测性。

封闭类的使用场景

封闭类适用于以下场景：

1. 当你想要创建一个基类，但只想允许特定的子类时。
2. 当你想要限制类的继承结构，以避免类的滥用或错误扩展时。

封闭类示例

  
public abstract sealed class Shape permits Circle, Rectangle, Triangle {  
    // 封闭类的基类代码  
}  
  
final class Circle extends Shape {  
    // 圆形的具体实现  
}  
  
final class Rectangle extends Shape {  
    // 矩形的具体实现  
}  
  
// 以下代码将无法编译，因为 Square 没有在 Shape 的 permits 子句中声明  
// final class Square extends Shape {  
//     // 正方形的具体实现  
// }  

在这个例子中，Shape是一个封闭类，它明确指定了哪些类可以作为其子类。这确保了Shape的继承结构是受控的，并且防止了任何未授权的扩展。

记录类

记录类是一种特殊的类，它主要用于创建不可变的数据传输对象（DTOs）。记录类的语法比传统的类更加简洁，它自动为所有字段生成构造函数、equals、hashCode和toString方法。

记录类的概念

记录类的概念是为了简化 Java 中不可变数据结构的创建。它们提供了一种快速定义类的方式，而无需编写大量的样板代码。记录类是不可变的，这意味着一旦创建，其状态就不能改变，这有助于避免并发问题和不必要的错误。

记录类的使用场景

记录类适用于以下场景：

1. 当你需要创建一个简单的数据结构，用于存储一组固定的值时。
2. 当你希望确保数据的不可变性，以提高代码的安全性和可维护性时。

记录类示例

  
record Point(int x, int y) {}  
  
public class Example {  
    public static void main(String[] args) {  
        Point point = new Point(10, 20);  
        System.out.println(point); // 输出 "Point[x=10, y=20]"  
    }  
}  

在这个例子中，我们定义了一个名为Point的记录类，它有两个字段：x和y。创建记录类时，Java 自动为我们生成了构造函数和toString方法，使得代码非常简洁。此外，由于记录类是不可变的，我们可以安全地在多线程环境中共享Point实例，而不必担心它们的内部状态会被改变。

总的来说，封闭类和记录类为 Java 开发者提供了更多的选择，以适应不同的编程场景。封闭类通过限制继承结构来增强类型安全性，而记录类则通过简化数据结构的创建来提高开发效率。这些新特性的引入，进一步丰富了 Java 语言的功能，使其更加现代化和高效。随着这些特性在未来的 Java 版本中得到进一步的发展和完善，我们有理由相信它们将成为 Java 编程中不可或缺的一部分。

其他重要语言特性

除了前面提到的模式匹配、未命名变量和未命名模式等特性，Java 在 JDK 8 至 21 的版本中还引入了许多其他重要的语言特性。这些特性涵盖了从代码简化到性能优化的各个方面，极大地提升了 Java 编程的便捷性和表达能力。接下来，我们将详细探讨其中的一些关键特性。

String 模板

Java 16 引入了字符串模板（String Templates），这是一种新的字符串字面量，它允许开发者以一种更加简洁和安全的方式来创建格式化的字符串。字符串模板通过str前缀定义，并支持多行字符串和插值表达式。

字符串模板的用法

字符串模板提供了一种新的字符串创建方式，它结合了字符串字面量的简洁性和String.format方法的格式化能力。开发者可以在模板中直接插入变量和表达式，而不需要额外的格式化步骤。

  
String name = "World";  
int value = 42;  
  
// 使用字符串模板创建格式化的字符串  
String message = `Hello, ${name}! The value is ${value * 2}.`;  
System.out.println(message); // 输出 "Hello, World! The value is 84."  

在这个例子中，我们使用${}来插入变量和表达式的值，这使得字符串的创建和格式化过程变得更加直观和方便。

字符串模板的优势

字符串模板的主要优势在于它的简洁性和易读性。它减少了字符串拼接和格式化的复杂性，使得代码更加清晰和易于维护。此外，由于字符串模板是编译时常量，它们在某些情况下还能提供更好的性能。

文本块

文本块（Text Blocks）是 Java 13 中引入的预览特性，它允许开发者以多行字符串的形式编写代码，而无需使用传统的转义序列。文本块通过三个双引号（"""）定义，并且保持了字符串字面量的原始格式。

文本块的用法

文本块特别适用于创建多行的字符串，例如在编写正则表达式、HTML 模板或 SQL 查询时。

  
String html = """  
    <html>  
        <body>  
            <h1>Title</h1>  
            <p>Paragraph with line breaks  
               and multiple lines.</p>  
        </body>  
    </html>  
    """;  
System.out.println(html);  

在这个例子中，我们定义了一个包含 HTML 内容的文本块，所有的换行符和空格都被保留，而不需要使用传统的\n转义序列。

文本块的优势

文本块的主要优势在于它们的易读性和编写效率。它们使得多行字符串的创建变得非常简单，同时避免了转义序列带来的混乱和错误。此外，文本块还支持跨多行的字符串连接，进一步提高了代码的灵活性。

Helpful NullPointerExceptions

Java 14 中引入了更加有用的NullPointerException，它提供了关于哪个变量为null的详细信息。这一特性通过-XX:+ShowCodeDetailsInExceptionMessages JVM 选项启用，它使得空指针异常更加易于调试。

Helpful NullPointerExceptions 的用法

当程序抛出NullPointerException时，JVM 会提供更多的堆栈跟踪信息，包括导致异常的变量名和代码位置。

  
String message = null;  
int length = message.length(); // 这里会抛出 NullPointerException  

在这个例子中，如果启用了详细异常信息，我们将会得到类似于以下的输出：

  
Exception in thread "main" java.lang.NullPointerException:  
    Cannot read field "length" because "message" is null  
    at com.example.Main.main(Main.java:10)  

Helpful NullPointerExceptions 的优势

这一特性的主要优势在于它提供了更多的调试信息，使得开发者能够快速定位和修复空指针异常。这种增强的异常信息极大地提高了 Java 程序的可维护性和稳定性。

Switch 表达式

Switch 表达式是 Java 12 中引入的预览特性，它为switch语句提供了一种更加简洁和灵活的替代方案。Switch 表达式使用yield关键字返回值，并且可以与模式匹配结合使用。

Switch 表达式的用法

Switch 表达式可以替代传统的switch语句，特别是在处理枚举类型和表达式时。

  
Day day = Day.MONDAY;  
int numLetters = switch (day) {  
    case MONDAY, FRIDAY, SUNDAY -> 6;  
    case TUESDAY -> 7;  
    default -> {  
        String s = day.toString();  
        int result = s.length();  
        yield result;  
    }  
};  
System.out.println(numLetters); // 输出 "5"  

在这个例子中，我们使用了一个switch表达式来根据day的值计算字母的数量。与传统的switch语句相比，Switch 表达式提供了一种更加简洁和函数式的方法来处理条件逻辑。

Switch 表达式的优势

Switch 表达式的主要优势在于它的简洁性和表达性。它减少了模板代码的数量，并且使得条件逻辑的编写更加直观和易于理解。此外，Switch 表达式还支持与模式匹配的结合使用，进一步提高了代码的灵活性和可读性。

总结

Java 语言在 JDK 8 至 21 的版本中引入了许多重要的新特性，这些特性不仅提高了代码的编写效率，还增强了程序的性能和安全性。从字符串模板和文本块的引入，到 Helpful NullPointerExceptions 和 Switch 表达式的改进，Java 不断地在进化，以满足现代软件开发的需求。随着这些特性在未来的 Java 版本中得到进一步的发展和完善，我们有理由相信它们将成为 Java 编程中不可或缺的一部分。

新 APIs 的探索

Java 平台的不断更新带来了丰富的新 APIs，这些 APIs 旨在提高开发者的生产力，简化复杂任务的处理，并增强 Java 在各个领域的应用能力。从集合操作的增强到数学函数的扩展，新 APIs 为 Java 开发者提供了更多的工具来构建高效、健壮的应用程序。

集合和数学函数 API

集合 API 是 Java 中使用最广泛的 API 之一，它提供了一系列的数据结构和算法来存储和操作对象集合。数学函数 API 则为数值计算提供了支持，包括随机数生成、复数操作等。在 JDK 8 至 21 的更新中，这两个领域的 API 得到了显著的扩展和改进。

新增集合 API 的特性和用法

在 JDK 8 中引入的 Stream API 彻底改变了 Java 中集合的处理方式，而在后续的版本中，这一 API 继续得到了增强。例如，JDK 16 引入了toList()方法，它简化了从 Stream 到 List 的转换过程，使得开发者可以更方便地进行数据收集。

  
List<String> list = Stream.of("apple", "banana", "cherry")  
                           .collect(Collectors.toList());  

此外，JDK 16 还引入了Map.of和Set.of等静态工厂方法，它们用于创建不可变的 Map 和 Set 实例，这不仅提高了代码的可读性，还减少了创建空集合时的内存消耗。

数学函数 API 的增强

Java 8 引入了java.util.function包，其中包括了一系列的函数式接口，为 Java 带来了函数式编程的特性。在此基础上，后续的 Java 版本继续增强数学函数 API。例如，JDK 11 中引入了Math.log10方法，用于计算一个数的以 10 为底的对数。

  
double result = Math.log10(100); // 结果为 2.0  

JDK 16 进一步扩展了数学函数库，包括对BigDecimal的改进，使得大数运算更加精确和高效。此外，JDK 16 还引入了Random和ThreadLocalRandom的新的 APIs，提供了更多的随机数生成选项。

实际应用

新的集合和数学函数 API 在实际应用中极大地提高了开发效率。例如，在处理大量数据时，Stream API 的链式操作和新的集合工厂方法使得代码更加简洁和易于理解。在科学计算和金融分析领域，增强的数学函数 API 提供了更精确的数值计算能力，帮助开发者实现了更复杂的数学模型。

结论

集合和数学函数 API 的持续更新和改进，反映了 Java 平台对开发者需求的响应和对现代编程挑战的适应。这些新 APIs 不仅提高了 Java 语言的表达能力，还为解决复杂问题提供了更多的工具和选项。随着 Java 平台的不断发展，我们可以期待未来会有更多的创新和改进，进一步丰富 Java 生态系统。

其他重要 API 更新

随着 Java 平台的不断演进，除了集合和数学函数 API 之外，还有许多其他的 API 得到了更新和增强，以满足现代应用程序的需求。这些更新涵盖了文件和 IO 操作、网络编程、时间日期处理等多个方面，为 Java 开发者提供了更加强大和灵活的工具集。

文件和 IO 操作的改进

Java 的文件和 IO 操作 API 在 JDK 8 至 21 期间经历了显著的改进。例如，JDK 11 引入了Files.walk方法，它提供了一种更加简洁的方式来遍历文件树。此外，JDK 14 增加了Files.mismatch方法，用于比较两个文件的内容差异，这对于文件校验和数据恢复等场景非常有用。

  
Path startPath = Paths.get("/path/to/start/directory");  
try (Stream<Path> stream = Files.walk(startPath)) {  
    stream.filter(Files::isRegularFile)  
          .forEach(path -> System.out.println(path));  
}  

网络编程的新特性

在网络编程方面，JDK 9 引入了java.net.http.HttpClient，这是一个全新的、非阻塞的 HTTP 客户端 API，它提供了更加简洁和强大的 HTTP 请求处理能力。这个新的 HTTP 客户端支持 HTTP/2 协议，并且提供了 WebSocket 支持，使得 Java 在处理现代网络应用时更加高效。

  
HttpClient client = HttpClient.newBuilder()  
                          .version(HttpClient.Version.HTTP_2)  
                          .build();  
  
HttpRequest request = HttpRequest.newBuilder()  
                                .uri(URI.create("https://example.com"))  
                                .GET()  
                                .build();  
  
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())  
    .thenApply(HttpResponse::body)  
    .thenAccept(System.out::println)  
    .join();  

时间和日期 API 的更新

Java 8 引入了java.time包，这个包提供了一套全新的日期和时间 API，它解决了旧版java.util.Date类中存在的问题，并提供了更好的时间日期处理能力。在后续的版本中，这个 API 继续得到了增强。例如，JDK 12 增加了LocalDate的ofEpochDay方法，它允许开发者直接从天数创建日期对象，而不需要通过ChronoLocalDate。

  
LocalDate date = LocalDate.ofEpochDay(10000); // 创建一个特定的日期  

结论

这些 API 的更新和增强不仅提高了 Java 语言的功能，还使得 Java 在处理文件操作、网络通信和时间日期处理等任务时更加高效和便捷。随着 Java 平台的不断发展，我们可以期待未来会有更多的创新和改进，进一步丰富 Java 生态系统，帮助开发者构建更加健壮和高效的应用程序。

性能改进的深入分析

Java 平台的性能改进一直是开发者社区关注的焦点。从 JDK 8 至 21，Oracle 和 OpenJDK 社区持续致力于优化 Java 虚拟机（JVM）和 Java 语言的性能，以满足日益增长的应用程序性能需求。这些改进包括内存管理、垃圾回收、即时编译器（JIT）优化、启动时间缩短等方面。

内存管理和垃圾回收

内存管理和垃圾回收是 Java 性能改进中的关键领域。有效的内存管理确保了应用程序能够高效地使用内存资源，而垃圾回收机制则负责回收不再使用的对象，防止内存泄漏。

弹性元空间

在 JDK 8 中，元空间（Metaspace）被引入作为PermGen（永久代）的替代品，用于存储类的元数据。与PermGen不同，元空间在本地内存中分配，理论上不受堆大小的限制。然而，随着应用程序规模的增长，元空间的内存使用也成为一个关注点。为了解决这一问题，JDK 16 引入了弹性元空间，它允许元空间的内存使用更加动态和可控，减少了对系统内存的占用。

G1 垃圾回收器

G1（Garbage-First）垃圾回收器自 JDK 9 起成为默认的垃圾回收器。G1 是一种并行、增量、并发的垃圾回收器，旨在提供可预测的停顿时间模型，同时保持高吞吐量。G1 通过将堆划分为多个区域（Region）并跟踪每个区域的垃圾回收优先级来工作。它定期执行小型的回收任务，以减少应用程序的停顿时间。

ZGC 和 Shenandoah 垃圾回收器

ZGC（Z Garbage Collector）和 Shenandoah 垃圾回收器是两个实验性的垃圾回收器，它们在 JDK 11 及后续版本中作为实验特性提供。这两种回收器都旨在为大型堆（多达 4TB）提供低延迟的垃圾回收。ZGC 通过染色指针技术和并发标记周期来实现低延迟，而 Shenandoah 则通过并发标记和压缩来减少停顿时间。

NUMA-Aware 内存分配

随着多核处理器的普及，非一致性内存访问（NUMA）架构变得越来越常见。JDK 14 引入了 NUMA-Aware 内存分配，它允许 JVM 根据处理器的 NUMA 拓扑结构来优化内存分配，从而提高内存访问效率和整体性能。

并行 Full GC 的改进

JDK 10 中引入了并行 Full GC，它通过在 Full GC 过程中使用多个 GC 线程来提高垃圾回收的效率。这种改进显著减少了 Full GC 的停顿时间，特别是在处理大型堆或长时间运行的应用程序时。

总结

内存管理和垃圾回收的性能改进对于 Java 应用程序的稳定性和响应性至关重要。通过引入新的垃圾回收器、优化内存分配策略和提供更灵活的垃圾回收选项，Java 平台能够更好地适应不同类型和规模的应用程序。随着 Java 技术的不断发展，我们可以期待未来会有更多的内存管理和垃圾回收方面的创新，以满足日益增长的性能需求。

JIT 编译器和运行时性能

Java 虚拟机（JVM）中的即时编译器（JIT）是 Java 性能优化的关键组件。JIT 编译器负责将字节码动态编译为本地机器码，以提高执行效率。随着 JDK 版本的迭代，JIT 编译器也在不断进化，引入了新的优化技术和特性，以提升运行时性能和编译效率。

JIT 编译器的优化

JIT 编译器的优化主要集中在减少编译时间和提高编译代码的质量上。这些优化包括更智能的编译触发策略、改进的热点检测算法、以及针对性能瓶颈的特定优化。

• 分层编译 ：JDK 11 引入了分层编译的概念，它允许 JVM 在不同的编译层次之间进行选择，以平衡编译时间和运行时性能。例如，JVM 可以使用快速的低层次编译器来编译不经常执行的代码，而将更高层次的优化编译器用于热点代码。
• 编译器探测 ：JDK 12 及后续版本中，编译器探测（也称为编译器引导）被引入，它允许 JVM 在运行时收集关于代码执行的更多信息，并使用这些信息来指导编译优化决策。
• 代码缓存和重用 ：JVM 通过缓存编译后的代码来避免重复编译相同的代码，这在处理具有多个版本的应用程序时尤其有用。此外，JVM 还可以在类加载器之间重用编译后的代码，减少了编译开销。

运行时性能监控和诊断工具

为了帮助开发者更好地理解和优化 Java 应用程序的性能，JVM 提供了一系列的运行时监控和诊断工具。

• Java Mission Control（JMC） ：JMC 是一个强大的性能分析工具，它可以收集和分析 JVM 的运行时信息，包括线程状态、内存使用情况和垃圾回收日志。
• Flight Recorder ：Flight Recorder 是 JDK 11 中引入的一个轻量级事件记录框架，它可以在后台记录 JVM 的详细运行时事件，而对性能的影响非常小。开发者可以在需要时启动详细的事件记录，以进行性能分析。
• JVM 统计信息 API ：JVM 统计信息 API（JVMS）提供了一组接口，允许应用程序查询 JVM 的运行时统计信息，如类加载次数、垃圾回收次数等。

启动时间缩短

启动时间是 Java 应用程序性能的一个重要方面，特别是在需要快速响应的场景中。从 JDK 9 开始，Oracle 致力于减少 JVM 的启动时间，通过优化类加载和初始化过程，以及减少启动时的 JVM 内部处理。

应用类数据共享（Application Class-Data Sharing, ACDS）

ACDS 是 JDK 11 中引入的一个特性，它允许 JVM 在多个 Java 进程之间共享已编译的类数据。通过这种方式，JVM 可以减少启动时的编译工作量，从而缩短启动时间。

快速应用启动（Fast Application Startup, FAS）

FAS 是 JDK 11 中的一个项目，旨在通过减少类元数据的加载和优化 JVM 的内存布局来加快应用启动速度。虽然 FAS 项目的一些目标在 JDK 11 中并未完全实现，但它为后续版本的启动时间优化奠定了基础。

总结

JIT 编译器和运行时性能的优化是 Java 平台持续进步的重要组成部分。通过引入新的编译策略、监控工具和启动时间缩短技术，Java 能够为开发者提供更加高效和稳定的运行时环境。随着 Java 技术的不断发展，我们可以期待未来会有更多的性能优化特性，以满足日益增长的性能需求和挑战。

安全改进的全面审视

Java 平台一直致力于提供安全可靠的编程环境，以保护用户和企业的数据安全。从 JDK 8 至 21，Java 的安全模型经历了一系列的改进，旨在提高安全性，防范新出现的威胁，并保持与现代安全标准和实践的一致性。

加密和认证 API

加密和认证 API 是 Java 安全体系中的重要组成部分，它们为 Java 应用程序提供了数据加密、解密、签名和验证等安全操作的能力。随着技术的发展，Java 对这些 API 进行了更新和增强，以支持新的加密算法和满足更高的安全标准。

新的加密算法和 API

• AES-GCM ：JDK 11 中引入了对 AES-GCM（Galois/Counter Mode）的支持，这是一种用于块加密算法的高效和安全的模式，特别适合处理网络通信中的数据加密和认证。
• TLS 1.3 ：Java 11 开始支持 TLS 1.3，这是传输层安全协议的最新版本，提供了更强大的加密算法、更少的握手轮次和更好的隐私保护。
• SHA-3 ：随着安全需求的不断演进，JDK 9 引入了对 SHA-3（Secure Hash Algorithm 3）的支持，这是新一代的哈希函数，旨在替代原有的 SHA-2。

密钥管理和证书处理

• 密钥封装机制（KEM）API ：JDK 21 中引入了密钥封装机制（Key Encapsulation Mechanisms）API，它提供了一种封装和解封装密钥的方法，这对于密钥交换和密钥管理非常重要。
• 证书透明度（Certificate Transparency, CT） ：Java 11 开始支持证书透明度 API，这是一种公开的、可审计的证书日志系统，用于监控和验证 SSL/TLS 证书的颁发。

安全随机数生成器

• DRBG（Deterministic Random Bit Generator） ：Java 11 中引入了基于 NIST SP 800-90A 标准的确定性随机比特生成器（DRBG），它提供了可预测的、高质量的随机数，适用于安全敏感的应用场景。

弃用和移除不安全的 API

• 不安全的加密算法 ：随着安全意识的提高，Java 社区逐渐弃用了一些被认为是不安全的加密算法，如 DES 和 SHA-1，并推荐使用更安全的替代品。
• 不安全的 SSL/TLS 协议 ：Java 11 开始弃用 SSL 和早期版本的 TLS 协议，鼓励开发者使用 TLS 1.3 或更高版本，以确保通信的安全性。

总结

加密和认证 API 的更新和增强是 Java 安全改进中的重要一环。通过引入新的加密算法、改进密钥管理和证书处理，以及提供更强大的随机数生成器，Java 平台能够更好地保护用户的数据安全和隐私。同时，通过弃用和移除不安全的 API，Java 鼓励开发者采用更加安全和现代的编程实践。随着 Java 技术的不断发展，我们可以期待未来会有更多的安全特性被引入，以应对不断变化的安全威胁和挑战。

安全管理器和权限控制

在 Java 安全模型中，安全管理器（Security Manager）和权限控制（Access Control）扮演着至关重要的角色。它们确保了 Java 应用程序在一个受控的环境中运行，防止恶意代码访问敏感资源或执行危险操作。随着 Java 版本的更新，这些安全机制也在不断地得到加强和优化。

安全管理器

安全管理器是 Java 安全架构的核心组件，它负责执行安全策略，控制对系统资源的访问。通过安全管理器，Java 平台能够实施一系列的安全限制，如文件系统访问、网络连接和加密算法的使用。

• 策略文件和权限 ：安全管理器通常与策略文件（如java.security）一起工作，这些文件定义了代码可以请求的权限。开发者可以根据需要自定义策略文件，以放宽或限制特定的权限。
• 安全管理器的配置 ：在 JDK 9 中，安全管理器的配置方式发生了变化。java.security文件不再位于 JRE 的lib/security目录下，而是被jdk.security文件所取代，这使得安全管理器的配置更加模块化和灵活。

权限控制

Java 的权限控制机制允许开发者精确地控制代码的访问权限。这些权限可以是文件系统访问、网络操作、安全属性修改等。

• java.security.Permissions ：这是一个用于定义和管理权限的类。开发者可以通过创建Permissions对象并将其传递给SecurityManager来设置应用程序的权限集。
• java.security.CodeSource ：这个类用于表示代码的来源，包括 URL 和证书信息。它与权限控制紧密相关，因为安全管理器可以根据代码来源来授予或拒绝特定的权限。

沙箱和 Applet API 的弃用

Applet API 在 JDK 11 中被标记为弃用，并在 JDK 14 中被完全移除。Applet 提供了在浏览器中运行 Java 程序的能力，但由于安全问题和现代 Web 技术的发展，它已经不再被推荐使用。随着 Applet API 的弃用，Java 的沙箱模型也得到了重新评估，以确保 Java 应用程序的安全性。

加强的 JVM 安全特性

• JVM 安全沙箱 ：JVM 本身提供了一个安全沙箱，限制了类加载器和类定义的权限。在 JDK 11 及后续版本中，这个沙箱得到了加强，以防止潜在的安全漏洞。
• JVM TI（Tool Interface） ：JVM TI 提供了一组 API，允许监控和控制运行中的 Java 虚拟机。在 JDK 11 中，对 JVM TI 的访问受到了限制，以减少潜在的安全风险。

总结

安全管理器和权限控制是 Java 平台安全性的关键组成部分。通过不断更新和改进这些机制，Java 确保了应用程序在一个受控的环境中运行，保护了用户的数据和系统资源。随着 Java 技术的不断发展，我们可以期待未来会有更多的安全特性被引入，以应对不断变化的安全威胁和挑战。开发者应当关注这些更新，确保他们的应用程序遵循最新的安全最佳实践。

启动和打包的新工具和方法

随着 Java 生态系统的发展，启动和打包应用程序的方式也在不断演进。为了满足现代应用程序对快速启动和部署的需求，Java 平台引入了一系列新的工具和方法，旨在简化开发流程，提高效率，并支持新的部署模式。

jlink 和 jpackage 工具

jlink（Java Linker）和 jpackage 是 Java 平台提供的新工具，它们使得创建定制的运行时映像和打包应用程序变得更加简单和高效。

jlink 工具

jlink 工具允许开发者创建一个定制的运行时映像（也称为“链接包”），这个映像包含了运行应用程序所需的最小化的 JVM 组件和应用程序代码。通过这种方式，开发者可以减少运行时的体积，提高启动速度，并减少对系统资源的占用。

• 减少运行时体积 ：传统的 JRE（Java 运行时环境）包含了许多不常用的功能和组件，这使得其体积相对较大。使用 jlink，开发者可以选择性地包含必要的模块，从而生成一个更小的运行时映像。
• 提高启动速度 ：较小的运行时映像意味着更少的加载时间，从而提高了应用程序的启动速度。
• 定制化部署 ：jlink 提供了高度的定制化能力，开发者可以根据应用程序的特定需求来构建运行时映像，例如，包含特定的语言包或不包含某些不常用的功能。

jpackage 工具

jpackage 工具是 Java 14 中引入的，用于将 Java 应用程序打包为平台特定的安装包。这个工具支持多种操作系统，包括 Windows、macOS 和 Linux，能够生成如 MSI、EXE、PKG、Deb 和 RPM 等格式的安装包。

• 一站式打包 ：jpackage 简化了打包流程，开发者只需一个命令就可以生成适用于目标平台的安装包。
• 集成式安装 ：生成的安装包可以集成到操作系统的包管理器中，使得应用程序的安装、更新和卸载与操作系统的其他软件一致。
• 支持多种平台 ：jpackage 支持跨平台打包，开发者可以使用相同的源代码生成适用于不同操作系统的安装包。

使用示例

以下是使用 jlink 和 jpackage 工具的基本示例：

  
# 使用 jlink 创建定制的运行时映像  
jlink --module-path <path-to-jdk>/jmods \  
       --add-modules java.base,java.desktop \  
       --output <output-directory>  
  
# 使用 jpackage 打包应用程序  
jpackage --type exe \  
         --input <application-directory> \  
         --runtime-image <path-to-runtime-image> \  
         --name <application-name> \  
         --main-jar <main-jar-file> \  
         --main-class com.example.Main  

在上述示例中，我们首先使用 jlink 创建了一个只包含必要模块的运行时映像，然后使用 jpackage 将应用程序打包为 Windows 平台的 EXE 安装文件。

总结

jlink 和 jpackage 工具的引入，为 Java 应用程序的部署提供了更多的灵活性和便捷性。通过这些工具，开发者可以创建定制化的运行时映像和平台特定的安装包，从而满足不同场景下的部署需求。随着 Java 平台的不断发展，我们可以期待未来会有更多的工具和方法来支持现代化的应用程序部署。

Jigsaw 项目和模块系统

Jigsaw 项目是 Java 发展史上的一个重要里程碑，它的目标是将 Java 平台模块化，从而提高 Java 应用程序的性能、安全性和可维护性。Jigsaw 项目的核心是引入了 Java 模块系统（也称为 Project Jigsaw），这是 Java 11 中的一个重要特性。

模块化的好处

模块化带来了多个好处，包括：

• 更清晰的依赖关系 ：模块系统强制定义了包和模块之间的依赖关系，使得依赖更加明确，减少了类路径冲突的可能性。
• 更好的封装 ：模块可以隐藏其内部的实现细节，只暴露必要的 API，从而保护了应用程序的核心代码不被外部直接访问。
• 更高效的类加载 ：模块系统允许 JVM 有选择地加载和卸载模块，这不仅减少了内存占用，还提高了应用程序的启动速度。
• 更灵活的版本管理 ：模块化使得单独的模块可以独立更新和维护，而不会影响到整个应用程序。

模块系统的基本概念

Java 模块系统基于以下几个基本概念：

• 模块 （Module）：一个模块是一个包含相关类和资源的容器。模块通过module声明来定义，并在module-info.java文件中指定。
• 依赖 （Requires）：模块之间通过requires声明来表达依赖关系。一个模块可以依赖其他模块，并使用这些模块提供的 API。
• 导出 （Exports）：模块可以导出包，使得其他模块可以使用这些包中的类。导出关系通过exports声明来定义。
• 打开 （Opens）：模块可以打开包，允许其他模块访问其内部的类。这通常用于模块间的服务提供者和使用者关系。

模块系统的使用

在 Java 11 及以上版本中，开发者需要使用模块系统来构建应用程序。以下是一个简单的模块化应用程序的例子：

  
// module-info.java  
module com.example.myapp {  
    requires com.example.commons;  
    requires java.sql;  
  
    exports com.example.myapp to com.example.commons;  
    opens com.example.myapp.internal to com.example.commons;  
}  

在这个例子中，我们定义了一个名为com.example.myapp的模块，它依赖于com.example.commons模块和 Java 标准库中的java.sql模块。我们还导出了com.example.myapp包给com.example.commons，并打开了com.example.myapp.internal包给com.example.commons。

总结

Jigsaw 项目和模块系统的引入标志着 Java 平台在模块化方面的重大进步。模块化不仅提高了代码的组织性和可维护性，还为 Java 应用程序的性能和安全性带来了显著的提升。随着 Java 平台的不断发展，模块系统将继续演进，为开发者提供更多的灵活性和控制力。开发者应当熟悉模块化的概念和最佳实践，以便充分利用这一特性。

Javadoc 和字节码的更新

随着 Java 语言和平台的发展，Javadoc 工具和字节码规范也在不断进化，以适应新的编程实践和性能需求。这些更新对于开发者来说至关重要，因为它们影响着代码的文档化、兼容性和执行效率。

Javadoc 的现代化

Javadoc 是 Java 开发者用来生成 API 文档的重要工具。在 Java 9 中，Javadoc 工具经历了一次重大更新，引入了多项新特性和改进。

新的文档标签和工具特性

• @thumbnail标签 ：这个新标签允许开发者在 Javadoc 中嵌入小型图像，增强了文档的可读性和直观性。
• @implSpec和@implNote标签 ：这两个标签分别用于描述实现的意图和注意事项，提供了一种标准化的方式来记录实现细节。
• Javadoc 预览特性 ：Java 9 引入了预览特性的概念，允许开发者尝试即将推出的 Javadoc 新特性。

HTML5 和搜索功能的引入

Javadoc 工具现在支持 HTML5，这意味着生成的文档可以利用现代 Web 技术，提供更好的跨设备兼容性和用户体验。此外，Javadoc 输出现在包括一个搜索框，允许用户快速查找 API 文档中的类、方法和属性。

字节码的改进和新增

Java 虚拟机（JVM）的字节码指令集和属性也在不断演进，以支持新的语言特性和性能优化。

动态类生成的改进

随着 Java 语言和 API 的发展，动态生成类的能力变得更加重要。例如，Java 9 引入了java.lang.invoke.MethodHandle的新方法，使得动态类生成更加高效和灵活。

新增的字节码指令和属性

• invokedynamic指令 ：这个指令已经在 Java 7 中引入，用于动态解析方法调用，支持动态语言和框架，如 Project Panama。
• 新增的类文件属性 ：Java 11 中引入了新的类文件属性，如Module和ModulePackages，它们与 Java 模块系统相关联，用于存储模块化的元数据。
• 新增的 Code Attribute ：Java 11 还引入了新的 Code Attribute，如StackMapTable，用于增强 JVM 的类型检查和安全性。

总结

Javadoc 和字节码的更新反映了 Java 平台对现代软件开发需求的响应。Javadoc 的现代化改进使得 API 文档更加丰富和易用，而字节码的增强则为 Java 语言的新特性和性能优化提供了支持。开发者应当关注这些更新，以便更好地利用 Java 平台提供的工具和特性。随着 Java 技术的不断发展，我们可以期待未来会有更多的创新和改进，进一步丰富 Java 生态系统。

新支持的平台和版本方案

随着技术的发展和市场需求的变化，Java 平台不断扩展其对新硬件和操作系统的支持。这些更新确保了 Java 应用程序能够在更广泛的设备和环境中运行，同时保持了跨平台兼容性。

跨平台支持和兼容性

Java 的核心优势之一是其跨平台性，这意味着在不同操作系统和硬件上运行的 Java 虚拟机（JVM）能够提供一致的运行时环境。为了维持这一优势，Java 开发团队持续对 JVM 进行优化，以支持新的处理器架构和操作系统版本。

新增平台的支持情况

在 JDK 8 至 21 的版本中，Java 增加了对多个新平台的支持，包括但不限于：

• Linux/RISC-V ：随着 RISC-V 开源处理器架构的兴起，Java 在 JDK 19 中增加了对 Linux/RISC-V 的支持，为开发者在这一新兴平台上构建 Java 应用程序提供了可能。
• macOS/AArch64 ：随着 Apple 转向自家设计的 ARM 架构处理器，Java 在 JDK 17 中增加了对 macOS/AArch64 的支持，确保了 Java 应用程序能够在新的 Mac 设备上运行。
• Windows/AArch64 ：同样，为了支持 Windows 操作系统上的 ARM 架构，Java 也在 JDK 16 中增加了对 Windows/AArch64 的支持。

版本兼容性和升级指南

为了帮助开发者平滑过渡到新版本，Java 提供了详细的版本兼容性指南。这些指南涵盖了从旧版本迁移到新版本的各个方面，包括 API 变更、废弃特性和新的模块系统。开发者可以参照这些指南来更新他们的应用程序，以利用新版本的特性和性能改进。

版本命名方案的变更

Java 的版本命名方案在 JDK 9 中经历了重大变化。在此之前，Java 的版本号遵循主版本号。次版本号的模式（例如，1.8 表示 JDK 8）。从 JDK 9 开始，Java 采用了新的命名方案，其中版本号包括了年份和更新次数（例如，9 表示 2017 年的更新版本）。

新版本命名的逻辑

新版本命名的逻辑旨在简化版本号的管理，并与 Java 的发布节奏保持一致。每个版本号都反映了它发布的时间，这使得开发者和用户能够更容易地了解他们使用的 Java 版本相对于其他版本的年龄。

版本迭代的速度和周期

自 JDK 9 以来，Java 的版本迭代速度加快，每六个月发布一个新的版本。这种快速迭代的模式使得 Java 能够更快地引入新特性和改进，同时也意味着开发者和用户需要更频繁地更新他们的 Java 环境。为了适应这种快速迭代，Java 也引入了长期支持（LTS）版本，这些版本会得到更长时间的支持和维护，适合需要稳定性和长期支持的企业级应用。

总结

新支持的平台和版本方案的变更体现了 Java 对不断变化的技术环境的适应性。通过增加对新硬件和操作系统的支持，Java 确保了其跨平台优势的持续存在。同时，新的版本命名方案和快速迭代模式使得 Java 能够更快地响应开发者的需求，推动 Java 生态系统的持续发展。开发者应当关注这些变化，以确保他们的应用程序能够充分利用 Java 平台的最新特性和改进。

弃用和移除的特性

随着 Java 平台的发展，某些旧特性可能会因为安全问题、更好的替代方案或者技术进步而变得过时。为了保持语言的现代化和高效性，Java 开发团队会定期审查和弃用这些特性，并在适当的时候将其移除。这一过程需要仔细的规划和透明的沟通，以确保开发者有足够的时间来适应变化。

弃用列表和未来展望

Java 社区维护了一个详细的弃用特性列表，这个列表随着每个新版本的发布而更新。开发者可以通过查阅这个列表来了解哪些特性已被弃用，以及它们的未来状态。

• Java EE 的移除 ：Java 企业版（Java EE）在 JDK 11 中被移除，转而作为独立的 Eclipse 项目继续发展。
• CORBA 模块的移除 ：Java 的 CORBA 支持在 JDK 11 中被移除，因为这项技术的使用已经变得较少。
• Nashorn JavaScript 引擎的移除 ：在 JDK 15 中，Nashorn JavaScript 引擎被标记为弃用，并在 JDK 11 中被完全移除。

移除特性的影响和替代方案

移除特性会对依赖这些特性的应用程序产生影响。因此，Java 提供了替代方案，以帮助开发者平滑过渡到新的技术。

• Java EE 的替代方案 ：对于 Java EE 的替代，开发者可以转向 Spring Boot、Quarkus 等现代框架，它们提供了类似的功能，并且更加轻量级和灵活。
• CORBA 的替代方案 ：对于需要 RPC（远程过程调用）的开发者，可以考虑使用 gRPC 或 RESTful 服务。
• Nashorn 的替代方案 ：对于需要在 Java 中执行 JavaScript 的开发者，可以考虑使用 GraalVM 的 JavaScript 引擎。

向后兼容性的挑战

向后兼容性是 Java 平台的一个重要原则，它确保了旧代码在新版本中仍然能够正常运行。然而，移除特性的决定可能会对向后兼容性造成挑战。

向后兼容性的策略

为了最小化对现有应用程序的影响，Java 开发团队采取了一系列策略：

• 清晰的弃用周期 ：Java 提供了清晰的弃用周期，通常在特性被完全移除之前会有一个警告期。
• 提供替代方案 ：Java 努力为每个被弃用的特性提供替代方案，以帮助开发者进行迁移。
• 逐步移除 ：对于大型特性，Java 可能会逐步移除，先将其标记为弃用，然后在后续版本中完全移除。

开发者如何应对弃用和移除

开发者应当密切关注 Java 社区的更新和公告，了解哪些特性正在被弃用或计划被移除。对于正在使用的弃用特性，开发者应该：

• 评估影响 ：分析应用程序中使用弃用特性的代码，评估迁移的成本和影响。
• 制定迁移计划 ：根据评估结果，制定详细的迁移计划，包括时间表和技术路线。
• 测试和验证 ：在迁移到新特性或替代方案后，进行充分的测试以确保应用程序的功能和性能。
• 更新文档和培训 ：更新内部文档，并为团队成员提供必要的培训，以确保所有人都了解新的变化。

通过这些措施，开发者可以确保他们的应用程序能够适应 Java 平台的变化，同时保持高效和稳定。

总结

在对 Java 平台从 JDK 8 至 21 的演进进行深入探讨后，我们可以总结出几个关键点，这些点不仅展示了 Java 语言和生态系统的发展，也为开发者提供了未来工作的方向和策略。

语言特性的进步

Java 语言在这段时间里经历了显著的增强，包括引入了函数式编程概念、模式匹配、未命名变量和模式、封闭类和记录类等。这些新特性不仅丰富了 Java 的表达能力，也使得代码更加简洁、可读性更强，同时提高了开发效率。

API 的扩展和更新

Java 标准库的扩展和更新为开发者提供了新的工具和能力。集合和数学函数 API 的增强、文件和 IO 操作的改进、网络编程的新特性以及安全管理器和权限控制的更新，都使得 Java 应用程序能够更好地处理复杂的任务和安全挑战。

性能和资源管理的优化

Java 虚拟机的性能和资源管理一直是 Java 开发的重点。JIT 编译器的优化、垃圾回收器的进步、内存管理和启动时间的改进，都显著提高了 Java 应用程序的运行效率和用户体验。

模块化和跨平台支持

Jigsaw 项目的完成和模块系统的引入，标志着 Java 平台在模块化方面取得了重大进展。这不仅提高了 Java 的内在质量和可维护性，也简化了应用程序的部署和分发。同时，Java 对新平台的支持，如 RISC-V 和 AArch64，确保了 Java 在多样化的计算环境中的持续相关性。

向后兼容性的维护

Java 社区对向后兼容性的承诺保证了新版本可以无缝地与现有代码库协同工作。尽管一些特性被弃用或移除，但 Java 提供了清晰的路线图和替代方案，以帮助开发者平滑过渡。

未来展望

随着 Java 的不断发展，我们可以预见到更多的创新和改进。新的语言特性、API 和性能优化将继续出现，以适应新的编程范式和技术趋势。同时，Java 社区将继续致力于提高平台的安全性、可维护性和用户友好性。

对于开发者来说，保持对 Java 新特性和最佳实践的了解至关重要。通过不断学习和适应变化，开发者可以确保他们的技能和应用程序保持最新，从而在不断变化的技术环境中保持竞争力。随着 Java 生态系统的不断壮大，Java 将继续作为企业级应用程序和现代云服务的坚实基础，引领软件开发的未来。