Java 8到Java 21新特性详解：LTS版本功能全解析

原创于 2025-07-02 18:00:00 发布 · 1.3k 阅读

26 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

收录于

Java那些事

大家好！作为一名Java开发者，我经常听到这样的感叹："Java 8之后的变化太大了！“确实，从2014年的Java 8到2023年的Java 21，Java语言经历了翻天覆地的变化。今天，我们就来一场Java版本的"时光之旅”，重点解析各个LTS(Long-Term Support)版本带来的革命性变化。准备好了吗？让我们一起探索这些改变我们编码方式的新特性！

一、为什么关注LTS版本？

在开始之前，先简单科普一下：LTS版本是Oracle提供的长期支持版本，通常每两年发布一次。对于企业级应用来说，LTS版本意味着更长的支持周期和更稳定的更新，因此我们重点分析这些版本。

二、Java 8（2014年）：函数式编程的黎明

Java 8堪称Java历史上最重要的更新之一，它引入了Lambda表达式和Stream API，彻底改变了Java的编程范式。

1. Lambda表达式：告别匿名内部类

// Java 7以前：使用匿名内部类
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};

// Java 8：使用Lambda表达式
Runnable r = () -> System.out.println("Hello World");

2. Stream API：集合操作的革命

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

// 传统方式
List<String> filtered = new ArrayList<>();
for (String name : names) {
    if (name.startsWith("A")) {
        filtered.add(name.toUpperCase());
    }
}

// Stream方式
List<String> filtered = names.stream()
    .filter(name -> name.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

3. Optional：优雅处理null

   // 以前
public String getUserName(User user) {
    if (user != null) {
        return user.getName();
    }
    return "Unknown";
}

// Java 8
public String getUserName(User user) {
    return Optional.ofNullable(user)
        .map(User::getName)
        .orElse("Unknown");
}

三、Java 11（2018年）：现代化改造

Java 11是继Java 8之后的又一个重要LTS版本，带来了许多实用特性。

1. 局部变量类型推断(var)

// 以前
Map<String, List<Integer>> map = new HashMap<>();

// Java 11
var map = new HashMap<String, List<Integer>>();

2. 新的字符串方法

String str = "  Hello Java 11  ";
str.isBlank();    // 检查是否为空或仅包含空白字符
str.strip();      // 去除首尾空白（比trim()更智能）
str.repeat(3);    // 重复字符串
"Java\n11\n".lines().count();  // 行数统计

3. HTTP Client API（标准化）

HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://example.com"))
    .build();

client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println)
    .join();

四、Java 17（2021年）：新时代的开始

Java 17是下一个LTS版本，引入了许多重要特性。

1. 密封类(Sealed Classes)：更安全的继承

public sealed class Shape
    permits Circle, Rectangle, Square { /*...*/ }

public final class Circle extends Shape { /*...*/ }
public final class Rectangle extends Shape { /*...*/ }
public final class Square extends Shape { /*...*/ }

2. 模式匹配instanceof

   // 以前
if (obj instanceof String) {
    String s = (String) obj;
    System.out.println(s.length());
}

// Java 17
if (obj instanceof String s) {
    System.out.println(s.length());
}

3. 文本块(Text Blocks)

// 以前
String json = "{\n" +
    "  \"name\": \"John\",\n" +
    "  \"age\": 30\n" +
    "}";

// Java 17
String json = """
    {
    "name": "John",
    "age": 30
    }
    """;

五、Java 21（2023年）：虚拟线程的革命

最新LTS版本Java 21带来了最令人期待的特性——虚拟线程(Virtual Threads)。

1. 虚拟线程：轻量级并发

// 创建虚拟线程
Thread.startVirtualThread(() -> {
    System.out.println("Hello from virtual thread!");
});

// 使用ExecutorService
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}

2. 模式匹配switch（最终版）

String formatted = switch (obj) {
    case Integer i -> String.format("int %d", i);
    case Long l    -> String.format("long %d", l);
    case Double d  -> String.format("double %f", d);
    case String s  -> String.format("String %s", s);
    default        -> obj.toString();
};

3. 序列化集合

// 创建不可变集合的新方法
List<String> list = List.of("a", "b", "c");
Set<String> set = Set.of("a", "b", "c");
Map<String, Integer> map = Map.of("a", 1, "b", 2);