了解 JDK 11 的新特性

# 章节一：JDK 11 简介

JDK 11 是 Java 语言的一个重要版本，于 2018 年 9 月发布。作为 Java 语言的里程碑，它带来了许多令人兴奋的特性和改进。本章将介绍 JDK 11 的一些重要特性，并讨论这些特性对 Java 开发者和应用程序的影响。

首先来看 JDK 11 的一些主要特性：

- **局部变量类型推断**：JDK 11 引入了 var 关键字，允许开发者在不失灵活性的情况下，更加简洁地声明局部变量。
- **新的 HTTP 客户端 API**：JDK 11 中引入了一个简单易用的 HTTP 客户端 API，使得进行 HTTP 通信变得更加便利。
- **模块化系统的改进**：JDK 9 引入了模块化系统，而 JDK 11 进一步完善了模块化系统，并提供了对启动模块（启动服务）的支持。
- **新的垃圾收集器**：JDK 11 引入了一种新的垃圾收集器，即 Z Garbage Collector（ZGC），它专注于减少垃圾收集的停顿时间，并且适用于大内存堆。

## 章节二：模块化系统的改进

在 JDK 9 中，引入了模块化系统，允许开发者将代码库分解为相互依赖的模块。而在 JDK 11 中，模块化系统也得到了一系列改进，提供了更好的灵活性和性能。

### 1. 模块路径
在 JDK 9 中，我们可以使用 `--module-path` 选项指定模块路径，从而加载模块。而在 JDK 11 中，除了使用 `--module-path` 选项外，还可以使用 `-p` 或 `--class-path` 选项，这样就可以混合使用模块路径和类路径，从而更好地兼容第三方库和旧有的类路径。

// 使用模块路径和类路径混合
java --module-path <module-path> -p <classpath> -m <module>/<main-class>

### 2. 隐藏内部 API
在 JDK 9 中，引入了模块化系统后，JDK 内部的一些 API 被标记为不推荐直接使用。到了 JDK 11，这些不推荐使用的内部 API 被进一步标记为不推荐，并且默认情况下被隐藏起来。这样做的目的是为了鼓励开发者遵循标准的 API，减少对 JDK 内部 API 的依赖。

### 3. 解决循环依赖
JDK 11 修复了 JDK 9 中的一个限制，允许模块间存在循环依赖。在 JDK 9 中，如果发现模块之间存在循环依赖，编译器会报错。而在 JDK 11 中，我们可以通过 `--limit-modules` 选项来解决循环依赖问题。

// 限制模块间的循环依赖
javac --limit-modules <module1>,<module2> <source-files>

通过这些改进，JDK 11 的模块化系统变得更加灵活，同时也更好地兼容了现有的类路径和第三方库。

在下一个章节，我们将介绍 JDK 11 中新增的 HTTP 客户端 API，让我们继续向下阅读。
# 章节三：HTTP 客户端 API

JDK 11 引入了一个全新的 HTTP 客户端 API，该 API 为开发人员提供了一种在不使用任何外部库的情况下进行 HTTP 请求的方式。新的 HTTP 客户端 API 支持异步和同步请求，并且可以与 Java 的 CompletableFuture 类结合使用，使得处理异步 HTTP 请求变得更加方便。

## HTTP 客户端 API 的基本用法
下面是一个简单的示例，演示了如何使用 JDK 11 的 HTTP 客户端 API 发起一个简单的 HTTP GET 请求：

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class HttpClientExample {
    public static void main(String[] args) {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://jsonplaceholder.typicode.com/posts/1"))
                .GET()
                .build();

        CompletableFuture<HttpResponse<String>> response = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        response.thenAccept(res -> {
            System.out.println("Response status code: " + res.statusCode());
            System.out.println("Response body: " + res.body());
        });

        // 阻塞等待异步请求完成
        response.join();
    }
}

在这个例子中，我们首先创建了一个 HttpClient 对象，然后使用 HttpRequest 类构建了一个 HTTP GET 请求。接着，我们通过调用 `sendAsync` 方法来异步发送请求，并使用 `thenAccept` 方法来处理异步请求完成后的响应。最后，我们调用 `join` 方法来阻塞等待异步请求的完成。

## HTTP 客户端 API 的简单封装
除了直接使用 HttpClient、HttpRequest 和 HttpResponse 来发送和处理 HTTP 请求外，我们还可以通过简单封装来实现更方便的使用。下面是一个简单的封装示例：

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.concurrent.CompletableFuture;

public class SimpleHttpClient {
    private HttpClient client;

    public SimpleHttpClient() {
        this.client = HttpClient.newHttpClient();
    }

    public CompletableFuture<HttpResponse<String>> get(String url) {
        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(url))
                .GET()
                .build();

        return client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
    }
}

通过这样的封装，我们可以更加便捷地发起 HTTP 请求：

public class Main {
    public static void main(String[] args) {
        SimpleHttpClient httpClient = new SimpleHttpClient();
        CompletableFuture<HttpResponse<String>> response = httpClient.get("https://jsonplaceholder.typicode.com/posts/1");

        response.thenAccept(res -> {
            System.out.println("Response status code: " + res.statusCode());
            System.out.println("Response body: " + res.body());
        });

        // 阻塞等待异步请求完成
        response.join();
    }
}

## 总结
JDK 11 的 HTTP 客户端 API 提供了一种方便、灵活的方式来进行 HTTP 请求，并且支持异步请求和 CompletableFuture，使得编写和处理 HTTP 请求变得更加简单和高效。这对于开发人员来说是一个非常有价值的改进。
### 章节四：局部变量类型推断

在 JDK 10 中引入的局部变量类型推断（Local-Variable Type Inference）功能，允许我们在不显式指定变量类型的情况下，使用 var 关键字声明局部变量。这一特性的引入旨在减少样板代码的数量，使代码更具可读性和简洁性。

#### 使用场景

局部变量类型推断在以下场景中特别有用：
1. 减少冗余的类型声明，在不牺牲可读性的前提下简化代码。
2. 使代码更易于重构，因为变量类型不再是其定义的一部分，所以可以更轻松地更改变量的类型而不影响其余代码。

#### 示例代码

// 传统的变量声明方式
List<String> traditionalList = new ArrayList<String>();

// 使用局部变量类型推断
var inferredList = new ArrayList<String>();

// 示例方法
public void printInferredList() {
    // 遍历 inferredList
    for (var item : inferredList) {
        System.out.println(item);
    }
}

// 局部变量类型推断在 lambda 表达式中的应用
var runnable = (Runnable) () -> {
    System.out.println("This is a runnable task");
};

#### 代码总结

通过使用 var 关键字，我们可以方便地声明局部变量而无需显式指定其类型。这样可以减少样板代码的数量，并使代码更具可读性。

#### 结果说明

使用局部变量类型推断可以大幅简化代码，提高代码的可读性和可维护性。然而需要注意，局部变量类型推断并不意味着我们应该放弃类型声明，对于复杂的数据结构，显示地指定类型还是更有利于代码的理解和维护。
### 章节五：新的垃圾收集器

在 JDK 11 中，引入了一款新的垃圾收集器，名为 Epsilon 垃圾收集器。Epsilon 垃圾收集器是一款非常简单的垃圾收集器，它不实施任何实质性的垃圾回收，主要用于性能测试和研究。

Epsilon 垃圾收集器适用于那些不需要内存管理的场景，避免了垃圾收集器带来的性能开销。

Epsilon 垃圾收集器的主要特点包括：
- 无垃圾收集：不执行实质性的垃圾回收操作。
- 低开销：几乎没有性能开销，适用于内存超出限制的测试场景。
- 实验性质：作为实验性特性，默认情况下是禁用的，可以通过参数 `-XX:+UseEpsilonGC` 来启用。

下面通过一个简单的示例来演示 Epsilon 垃圾收集器的使用：

public class EpsilonGCExample {
    public static void main(String[] args) {
        long[] arr = new long[1000000];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = i;
        }
    }
}

代码解释：
- 在这个示例中，我们创建了一个包含 100 万个长整型数的数组。
- 然后，我们对数组中的每个元素进行了赋值操作。

运行这段代码时，可以添加 `-XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC` 参数来启用 Epsilon 垃圾收集器。然后观察程序运行的性能和内存情况，可以发现由于 Epsilon 垃圾收集器不执行实质性的垃圾回收操作，因此内存占用非常高，但程序性能却得到了改善。

通过这个示例，我们可以初步了解 JDK 11 中引入的 Epsilon 垃圾收集器及其适用场景，同时也体现了 JDK 11 在性能优化方面的一项重要改进。

在实际开发中，可以根据项目的特性和需要选择合适的垃圾收集器，以达到更好的性能表现和资源利用效率。
### 章节六：其他改进和特性

JDK 11 中除了上述主要特性之外，还有一些其他的改进和特性。其中包括：

1. **ZGC（Z Garbage Collector）垃圾收集器的加入**

JDK 11 中引入了 ZGC 垃圾收集器，它是一种低延迟垃圾收集器，旨在为大内存堆提供预期的低延迟性能。ZGC 最大的特点是不会出现长时间的停顿，垃圾收集的停顿时间不受堆大小或活跃集大小的影响。

public class ZgcDemo {
    public static void main(String[] args) {
        System.out.println("ZGC垃圾收集器示例");
        // 在此处编写使用ZGC垃圾收集器的代码示例
    }
}

**代码总结**：上述代码展示了一个简单的使用ZGC垃圾收集器的示例。

**结果说明**：ZGC垃圾收集器可以在大内存堆上提供低延迟性能，并且不会出现长时间的停顿。

2. **Epsilon 垃圾收集器**

JDK 11 中引入了一种实验性的垃圾收集器 Epsilon，它是一种不执行任何实际垃圾收集操作的垃圾收集器。Epsilon 垃圾收集器主要用于性能调优、短生命周期的测试和特殊工作负载场景。

public class EpsilonDemo {
    public static void main(String[] args) {
        System.out.println("Epsilon垃圾收集器示例");
        // 在此处编写使用Epsilon垃圾收集器的代码示例
    }
}

**代码总结**：上述代码展示了一个简单的使用Epsilon垃圾收集器的示例。

**结果说明**：Epsilon垃圾收集器可以在性能调优、短生命周期测试和特殊工作负载场景中发挥作用。

3. **其他改进**

除了上述特性之外，JDK 11 还包括许多其他改进，如 Unicode 10 支持、TLS 1.3 支持、新的时间API改进等。这些改进和特性的加入进一步提升了 JDK 11 的功能和性能。

总的来说，JDK 11 不仅在模块化系统、HTTP 客户端 API、局部变量类型推断等方面有重大改进，还引入了新的垃圾收集器和许多其他改进，使得 JDK 11 成为一次重要的更新。

以上即为 JDK 11 中其他改进和特性的介绍。

**结语**：本章节介绍了 JDK 11 中一些其他改进和特性，包括新的垃圾收集器ZGC和Epsilon，以及其他一些改进。这些改进和特性的加入进一步提升了 JDK 11 的功能和性能。