本文目录导读：
- 模块化系统（最重要特性）
- JShell（交互式编程工具）
- 私有接口方法
- 集合工厂方法（of 方法）
- Stream API 增强
- Optional 增强
- 进程 API 改进
- 改进的 try-with-resources
- HttpClient（标准化）
- 钻石操作符改进
- 接口中的私有方法（详细示例）
Java 9 最重要的特性是模块化系统（Project Jigsaw），但也包含了许多其他实用特性，下面用具体案例来演示主要新特性：
模块化系统（最重要特性）
模块定义 (module-info.java)：
// com.example.myapp/module-info.java
module com.example.myapp {
requires java.sql;
requires transitive java.logging;
exports com.example.myapp.api;
uses com.example.myapp.spi.ServiceProvider;
}
使用模块的示例：
// 模块A的定义
module com.example.util {
exports com.example.util.strings;
exports com.example.util.collections;
}
JShell（交互式编程工具）
$ jshell
| 欢迎使用 JShell -- 版本 9
| 要大致了解该版本, 请键入: /help intro
jshell> int add(int a, int b) {
...> return a + b;
...> }
| 已创建 方法 add(int,int)
jshell> add(5, 3)
$1 ==> 8
jshell> /exit
私有接口方法
public interface Calculator {
// Java 9 允许接口中的私有方法
default int addNumbers(int... nums) {
return calculate(nums, 0);
}
default int multiplyNumbers(int... nums) {
return calculate(nums, 1);
}
// 私有方法（Java 9 新特性）
private int calculate(int[] nums, int initial) {
int result = initial;
for (int num : nums) {
if (initial == 0) {
result += num;
} else {
result *= num;
}
}
return result;
}
}
集合工厂方法（of 方法）
import java.util.*;
public class CollectionFactoryExample {
public static void main(String[] args) {
// 创建不可变集合
List<String> list = List.of("Java", "Python", "JavaScript");
Set<Integer> set = Set.of(1, 2, 3, 4, 5);
Map<String, Integer> map = Map.of("one", 1, "two", 2);
// 创建 Map 的高级方法（超过10个键值对）
Map<String, Integer> largeMap = Map.ofEntries(
Map.entry("a", 1),
Map.entry("b", 2),
// ... 更多条目
Map.entry("z", 26)
);
System.out.println(list);
System.out.println(set);
System.out.println(map);
}
}
Stream API 增强
import java.util.stream.Stream;
public class StreamEnhancements {
public static void main(String[] args) {
// takeWhile: 获取满足条件的元素直到第一个不满足条件
Stream.of(1, 2, 3, 4, 5, 6, 7, 8)
.takeWhile(n -> n < 5)
.forEach(System.out::print); // 输出: 1234
System.out.println();
// dropWhile: 丢弃满足条件的元素直到第一个不满足条件
Stream.of(1, 2, 3, 4, 5, 6, 7, 8)
.dropWhile(n -> n < 5)
.forEach(System.out::print); // 输出: 5678
System.out.println();
// ofNullable: 避免空指针
Stream.ofNullable(null)
.forEach(System.out::println); // 不输出任何内容
// iterate 重载
Stream.iterate(1, n -> n < 100, n -> n * 2)
.forEach(n -> System.out.print(n + " ")); // 1 2 4 8 16 32 64
}
}
Optional 增强
import java.util.Optional;
import java.util.stream.Stream;
public class OptionalEnhancements {
public static void main(String[] args) {
// ifPresentOrElse: 如果存在则执行一个操作，否则执行另一个操作
Optional<String> optional = Optional.of("Hello");
optional.ifPresentOrElse(
value -> System.out.println("Value: " + value),
() -> System.out.println("Value is empty")
);
// or: Optional 为空则返回另一个 Optional
Optional<String> empty = Optional.empty();
Optional<String> fallback = empty.or(() -> Optional.of("Default"));
System.out.println(fallback.get()); // 输出: Default
// stream: 将 Optional 转换为 Stream
Optional<String> opt = Optional.of("Java");
opt.stream().forEach(System.out::println);
}
}
进程 API 改进
import java.lang.ProcessHandle;
import java.util.stream.Collectors;
public class ProcessAPIExample {
public static void main(String[] args) {
// 获取当前进程信息
ProcessHandle currentProcess = ProcessHandle.current();
System.out.println("当前进程 PID: " + currentProcess.pid());
System.out.println("当前进程信息: " + currentProcess.info());
// 获取所有运行中的进程
ProcessHandle.allProcesses()
.forEach(process -> {
System.out.printf("PID: %d, Command: %s%n",
process.pid(),
process.info().command().orElse("unknown"));
});
}
}
改进的 try-with-resources
import java.io.BufferedReader;
import java.io.FileReader;
public class TryWithResourcesExample {
public static void main(String[] args) {
// Java 9: 可以在 try 中使用已有变量
BufferedReader reader = new BufferedReader(new FileReader("test.txt"));
// 之前需要声明在 try 中，现在可以直接使用
try (reader) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
HttpClient（标准化）
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) throws Exception {
// 同步请求
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.github.com/users/octocat"))
.GET()
.build();
HttpResponse<String> response = client.send(request,
HttpResponse.BodyHandlers.ofString());
System.out.println("响应状态码: " + response.statusCode());
System.out.println("响应体: " + response.body());
// 异步请求
CompletableFuture<HttpResponse<String>> future =
client.sendAsync(request, HttpResponse.BodyHandlers.ofString());
future.thenAccept(res -> {
System.out.println("异步响应: " + res.body());
}).join();
}
}
钻石操作符改进
// Java 9 允许在匿名类中使用钻石操作符
public class DiamondOperatorImprovement {
public static void main(String[] args) {
// 以前不允许，现在可以
Comparator<String> comparator = new Comparator<>() {
@Override
public int compare(String s1, String s2) {
return s1.compareTo(s2);
}
};
}
}
接口中的私有方法（详细示例）
interface StringHelper {
// 默认方法
default String reverse(String input) {
return process(input, true);
}
default String removeVowels(String input) {
return process(input, false);
}
// 私有方法（Java 9 新特性）
private String process(String input, boolean reverseStr) {
String result = input.toLowerCase();
if (reverseStr) {
return new StringBuilder(result).reverse().toString();
}
return result.replaceAll("[aeiou]", "");
}
// 静态方法也可以有私有方法
static String toUpperCase(String input) {
return processStatic(input);
}
private static String processStatic(String input) {
return input.toUpperCase();
}
}
这些是 Java 9 的主要特性示例，模块化系统是最重要的变更，而其他特性如集合工厂方法、Stream 增强、私有接口方法等都是日常开发中非常有用的改进。
