Java 10 局部变量类型推断

概述

Java 10（2018年3月）是第一个采用新发布周期（每6个月一个版本）的版本，主要特性是局部变量类型推断（var 关键字）。

var 关键字

var 允许编译器自动推断局部变量的类型。

基本用法

// 传统方式
String message = "Hello, World!";
ArrayList<String> list = new ArrayList<String>();
Map<String, List<Integer>> map = new HashMap<String, List<Integer>>();

// 使用 var
var message = "Hello, World!";  // 推断为 String
var list = new ArrayList<String>();  // 推断为 ArrayList<String>
var map = new HashMap<String, List<Integer>>();  // 推断为 HashMap<String, List<Integer>>

适用场景

// 1. 局部变量声明
var name = "Alice";
var age = 25;
var price = 19.99;

// 2. 增强 for 循环
var numbers = List.of(1, 2, 3, 4, 5);
for (var number : numbers) {
    System.out.println(number);
}

// 3. 传统 for 循环
for (var i = 0; i < 10; i++) {
    System.out.println(i);
}

// 4. try-with-resources
try (var reader = new BufferedReader(new FileReader("file.txt"))) {
    var line = reader.readLine();
}

// 5. Lambda 参数（Java 11）
// (var x, var y) -> x + y

不适用场景

// 1. 成员变量 - 不允许
class MyClass {
    var field = "error";  // 编译错误
}

// 2. 方法参数 - 不允许
public void method(var param) {}  // 编译错误

// 3. 返回类型 - 不允许
public var getResult() {}  // 编译错误

// 4. 没有初始化 - 不允许
var x;  // 编译错误
x = 10;

// 5. 初始化为 null - 不允许
var obj = null;  // 编译错误

// 6. 数组初始化器 - 不允许
var arr = {1, 2, 3};  // 编译错误
var arr = new int[]{1, 2, 3};  // 正确

// 7. Lambda 表达式 - 不允许
var lambda = (x, y) -> x + y;  // 编译错误
Comparator<String> lambda = (x, y) -> x.compareTo(y);  // 正确

最佳实践

// ✅ 好的用法 - 类型明显
var list = new ArrayList<String>();
var stream = list.stream();
var reader = new BufferedReader(new FileReader("file.txt"));

// ❌ 不好的用法 - 类型不明显
var result = someMethod();  // 不知道返回什么类型
var data = getData();       // 不知道是什么数据

// ✅ 好的用法 - 简化泛型
var map = new HashMap<String, List<Map<Integer, String>>>();

// ❌ 不好的用法 - 基本类型可能有歧义
var num = 1;      // int
var num = 1L;     // long
var num = 1.0;    // double
var num = 1.0f;   // float

不可变集合增强

copyOf 方法

// 创建不可变副本
List<String> original = new ArrayList<>();
original.add("a");
original.add("b");

List<String> copy = List.copyOf(original);
// copy.add("c");  // 抛出 UnsupportedOperationException

// 对于已经不可变的集合，返回同一个对象
List<String> immutable = List.of("a", "b");
List<String> copy2 = List.copyOf(immutable);
System.out.println(immutable == copy2);  // true

Collectors.toUnmodifiableList/Set/Map

List<String> list = Stream.of("a", "b", "c")
    .collect(Collectors.toUnmodifiableList());

Set<String> set = Stream.of("a", "b", "c")
    .collect(Collectors.toUnmodifiableSet());

Map<String, Integer> map = Stream.of("a", "b", "c")
    .collect(Collectors.toUnmodifiableMap(
        s -> s,
        s -> s.length()
    ));

Optional.orElseThrow()

Optional<String> optional = Optional.of("hello");

// Java 10 之前
String value = optional.orElseThrow(() -> new NoSuchElementException());

// Java 10 之后 - 无参版本
String value = optional.orElseThrow();  // 抛出 NoSuchElementException

应用程序类数据共享 (Application CDS)

允许将应用程序类放入共享存档，加快启动速度。

# 1. 创建类列表
java -Xshare:off -XX:+UseAppCDS -XX:DumpLoadedClassList=classes.lst -jar app.jar

# 2. 创建共享存档
java -Xshare:dump -XX:+UseAppCDS -XX:SharedClassListFile=classes.lst \
     -XX:SharedArchiveFile=app.jsa -jar app.jar

# 3. 使用共享存档运行
java -Xshare:on -XX:+UseAppCDS -XX:SharedArchiveFile=app.jsa -jar app.jar

G1 垃圾回收器改进

并行 Full GC

Java 10 中 G1 的 Full GC 改为并行执行，减少停顿时间。

# G1 是 Java 9+ 的默认垃圾回收器
java -XX:+UseG1GC -jar app.jar

线程本地握手

允许在不执行全局 VM 安全点的情况下对单个线程执行回调，减少 JVM 停顿。

其他改进

根证书

JDK 中包含了一组默认的根证书（CA），使 TLS 连接开箱即用。

基于时间的版本号

$FEATURE.$INTERIM.$UPDATE.$PATCH

例如：10.0.1
- FEATURE: 10 (功能版本)
- INTERIM: 0 (中间版本)
- UPDATE: 1 (更新版本)

总结

特性	说明
var 关键字	局部变量类型推断
不可变集合	copyOf、toUnmodifiable*
Optional	orElseThrow() 无参版本
Application CDS	应用程序类数据共享
G1 并行 Full GC	减少 GC 停顿时间

Java 10 的 var 关键字是最实用的特性，可以显著减少样板代码，但应该在类型明显的场景下使用，保持代码可读性。