Java 11

原文：链接

作者：Benjamin Winterberg

翻译：Wang Wei

Java11 已于 2018/09/25 成功发布，不过目前 绝大多数人 在生产环境仍旧使用的是 Java 8。这篇以案例为主的教程涵盖了从 Java 9 到 Java 11 的绝大多数重要的语法与 API 特性。让我们开始吧！

局部变量类型推断

Java 10 引入了一个新的语言关键字 var，它可以在声明局部变量 时替换类型信息（ 局部 意味着方法体内的变量声明）。

Java 10 之前，变量的声明形式如下：

1
String text = "Hello Java 9";

现在，你可以使用 var 替换 String 。编译器将会从变量的赋值中推断出它的正确类型。在这个例子里 变量 text 即为 String 类型：

1
var text = "Hello Java 10";

不同于 Javascript 中的 var 关键字，Java 中的 var 声明的变量仍旧是静态类型。你不能再次赋予另一个与原类型不符的变量值。

1
2
var text = "Hello Java 11";
text = 23;  // ERROR: Incompatible types(类型错误)

var 关键字还可以与 final 一起使用，意义同之前的版本一样，表示不可修改。

1
2
final var text = "Hello Java 10";
text = "Hello Java 11"; // Cannot assign a value to final variable 'text'

当编译器不能正确识别出变量的数值类型时，var 将不被允许使用。下面这些代码都是没法编译的代码：

1
2
3
4
5
// Cannot infer type:
var a;
var nothing = null;
var lambda = () -> System.out.println("Pity!");
var method = this::someMethod;

局部变量类型推断在与复杂的泛型类型结合时，能放大它的价值。在下面这个例子中，current 是有着一个冗长的数据类型 Map<String, List<Integer>> ，不过它的类型声明可以被 var 这个关键字简单地替换掉，让你避免了写一大窜的类型麻烦事。

1
2
3
4
5
6
var myList = new ArrayList<Map<String, List<Integer>>>();

for (var current : myList) {
    // current is infered to type: Map<String, List<Integer>>
    System.out.println(current);
}

从 Java 11 开始，lambda 表达式的参数也允许使用 var 关键字，这样使得你可以为这些参数添加注解标识：

1
Predicate<String> predicate = (@Nullable var a) -> true;

Tip：在 Intellij IDEA 中，你可以在按住 CMD / CTRL 的同时将鼠标悬停在变量上，以显示变量的推断类型。

HTTP Client

Java 9 引入了一个新的孵化 HttpClient API 来处理 HTTP 请求。从 Java 11 开始，这个 API 已经可以在标准库 java.net 中使用了。让我们来探索一下通过这个 API 我们可以做些什么。

这个新的 HttpClient 既可以被同步使用，也可以被异步使用。同步请求将会阻塞当前的线程，直到返回响应消息。BodyHandlers 定义了响应消息体的类型（e.g string，byte-array 或 file）:

1
2
3
4
5
6
7
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://wangwei.one"))
    .GET()
    .build();
var client = HttpClient.newHttpClient();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

同样的请求也可以被异步执行。调用 sendAsync 方法不会阻塞当前线程，并且会返回 CompletableFuture 对象，用来构建异步执行结果的操作流。

1
2
3
4
5
6
7
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://wangwei.one"))
    .build();
var client = HttpClient.newHttpClient();
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);

我们可以省略 .GET() 的调用，因为它默认的请求方式。

下面这个列子，我们以 POST 的方法向指定的 URL 发送数据。类似于 BodyHandlers ，你可以使用 BodyPublishers 去定义请求消息体中你想要发送的数据类型，例如 strings, byte-arrays,files 或 input-streams:

1
2
3
4
5
6
7
8
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://postman-echo.com/post"))
    .header("Content-Type", "text/plain")
    .POST(HttpRequest.BodyPublishers.ofString("Hi there!"))
    .build();
var client = HttpClient.newHttpClient();
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());      // 200

最后这个列子来演示如何通过 BASIC-AUTH 来执行身份认证。

1
2
3
4
5
6
7
8
9
10
11
12
13
var request = HttpRequest.newBuilder()
    .uri(URI.create("https://postman-echo.com/basic-auth"))
    .build();
var client = HttpClient.newBuilder()
    .authenticator(new Authenticator() {
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication("postman", "password".toCharArray());
        }
    })
    .build();
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());      // 200

Collections

像 List, Set 和 Map 这样的集合，它们的 API 也得到了扩展。List.of 可以从给定的参数中创建一个不可变的 list。List.copyOf 可以创建一个 list 的不可变副本。

1
2
3
var list = List.of("A", "B", "C");
var copy = List.copyOf(list);
System.out.println(list == copy);   // true

因为 list 已经是不可变的，所以实际上不需要实际地地去创建 list 实例的副本，因此 list 和 copy 是相同的实例。 但是，如果你复制一个可变列表，那么 copy 确定就是一个新实例，因此在改变原始 list 时，要保证没有副作用产生：

1
2
3
var list = new ArrayList<String>();
var copy = List.copyOf(list);
System.out.println(list == copy);   // false

当创建不可变的 maps 时，你不需要亲自去创建一个完整的 map 集合，你可以直接通过 Map.of 来进行创建：

1
2
var map = Map.of("A", 1, "B", 2);
System.out.println(map);    // {B=2, A=1}

Java 11 中的不可变集合仍然使用旧 Collection API 中的相同接口。 但是，如果尝试通过添加或删除元素来修改不可变集合，则会抛出 java.lang.UnsupportedOperationException。 幸运的是，如果你尝试改变不可变集合，Intellij IDEA 会通过检查发出警告。

Streams

Java8 中介绍的 Stream 也新增了方法。Stream.ofNullable 可以从单个元素中构造一个 Stream:

1
Stream.ofNullable(null).count(); // 0

dropWhile 与 takeWhile 方法可以用来决定 stream 中的哪些元素可以被抛弃：

1
2
3
4
5
6
7
Stream.of(1, 2, 3, 2, 1)
    .dropWhile(n -> n < 3)
    .collect(Collectors.toList());  // [3, 2, 1]

Stream.of(1, 2, 3, 2, 1)
    .takeWhile(n -> n < 3)
    .collect(Collectors.toList());  // [1, 2]

如果你对 Streams 不是很熟悉，你可以看看这篇文章 Java 8 Streams Tutorial.

Optionals

Optionals 也新增了一些非常好用的方法。例如，现在你可以简单地将 Optionals 转换为 Streams，或者使用另一个 optional 作为一个空 optional 的 fallback。

1
2
3
4
5
Optional.of("foo").orElseThrow();     // foo
Optional.of("foo").stream().count();  // 1
Optional.ofNullable(null)
    .or(() -> Optional.of("fallback"))
    .get();                           // fallback

Strings

最基本的类之一 String 新增了一些辅助方法，用以修剪或检查空格以及对字符串进行流化处理：

1
2
3
4
5
6
" ".isBlank();                // true
" Foo Bar ".strip();          // "Foo Bar"
" Foo Bar ".stripTrailing();  // " Foo Bar"
" Foo Bar ".stripLeading();   // "Foo Bar "
"Java".repeat(3);             // "JavaJavaJava"
"A\nB\nC".lines().count();    // 3

InputStreams

最后但并非最不重要的是，InputStream 最终获得了一个非常有用的方法来将数据传输到 OutputStream，这是一个在处理原始数据流时非常常见的用例。

1
2
3
4
5
6
var classLoader = ClassLoader.getSystemClassLoader();
var inputStream = classLoader.getResourceAsStream("myFile.txt");
var tempFile = File.createTempFile("myFileCopy", "txt");
try (var outputStream = new FileOutputStream(tempFile)) {
    inputStream.transferTo(outputStream);
}

其他 JVM 特性

这些是 - 在我看来 - 从 Java 8 迁移到 11 时最有趣的语言新 API 功能。但是功能列表并没有在这里结束。 最新的 Java 版本中包含了更多内容：