跳至主要內容

Java新特性

Salmon2026/1/15大约 5 分钟Java面试Java面试面试题后端

Java 新特性面试题

本章涵盖 Java 8 到 Java 21 的重要新特性，这些是 2026 年 Java 面试的高频考点。

Java 版本演进

版本发布时间支持周期重要特性
Java 82014.03LTSLambda、Stream、Optional
Java 112018.09LTSvar、HTTP Client、ZGC
Java 172021.09LTSSealed Classes、Pattern Matching
Java 212023.09LTS虚拟线程、Record Patterns

Java 8 特性

Q1: Lambda 表达式的本质是什么？

Lambda 表达式本质是函数式接口的匿名实现，编译后会生成一个私有静态方法，通过 invokedynamic 指令调用。

// Lambda 表达式
Runnable r = () -> System.out.println("Hello");

// 等价于匿名内部类
Runnable r = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
};

函数式接口：只有一个抽象方法的接口，用 @FunctionalInterface 标注。

常用函数式接口：

接口方法说明
Supplier<T>T get()无参返回值
Consumer<T>void accept(T)有参无返回
Function<T,R>R apply(T)有参有返回
Predicate<T>boolean test(T)断言判断

Q2: Stream 的中间操作和终端操作？

List<String> result = list.stream()
    .filter(s -> s.length() > 3)    // 中间操作：过滤
    .map(String::toUpperCase)        // 中间操作：转换
    .sorted()                        // 中间操作：排序
    .distinct()                      // 中间操作：去重
    .limit(10)                       // 中间操作：限制数量
    .collect(Collectors.toList());   // 终端操作：收集
类型特点示例
中间操作惰性求值，返回 Streamfilter、map、sorted
终端操作触发计算，返回结果collect、forEach、count

Q3: Optional 如何避免空指针？

// 错误用法：仍然可能 NPE
Optional<User> opt = findUser(id);
User user = opt.get();  // 如果为空会抛异常

// 正确用法
String name = findUser(id)
    .map(User::getName)
    .orElse("Unknown");

// 链式处理
String city = findUser(id)
    .flatMap(User::getAddress)
    .map(Address::getCity)
    .orElseThrow(() -> new RuntimeException("Not found"));

Java 11 特性

Q4: var 关键字的使用场景？

var 是局部变量类型推断，编译时确定类型。

// 可以使用 var
var list = new ArrayList<String>();  // 推断为 ArrayList<String>
var stream = list.stream();          // 推断为 Stream<String>
var entry : map.entrySet()           // for-each 循环

// 不能使用 var
var x;                    // 必须初始化
var arr = {1, 2, 3};      // 数组初始化器不行
var lambda = () -> {};    // Lambda 不行

Q5: HTTP Client API 的使用？

Java 11 引入了新的 HTTP Client，支持 HTTP/2 和 WebSocket。

// 同步请求
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/users"))
    .header("Content-Type", "application/json")
    .GET()
    .build();

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

// 异步请求
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
    .thenApply(HttpResponse::body)
    .thenAccept(System.out::println);

Java 17 特性

Q6: Sealed Classes 密封类的作用？

密封类限制哪些类可以继承它，增强类型安全。

// 定义密封类
public sealed class Shape permits Circle, Rectangle, Triangle {
}

// 允许的子类必须是 final、sealed 或 non-sealed
public final class Circle extends Shape {
    private double radius;
}

public sealed class Rectangle extends Shape permits Square {
}

public non-sealed class Triangle extends Shape {
    // non-sealed 允许任意继承
}

Q7: Pattern Matching 模式匹配？

// instanceof 模式匹配（Java 16+）
if (obj instanceof String s) {
    System.out.println(s.length());  // 直接使用 s
}

// switch 模式匹配（Java 21 正式）
String result = switch (obj) {
    case Integer i -> "Integer: " + i;
    case String s  -> "String: " + s;
    case null      -> "null";
    default        -> "Unknown";
};

Q8: Record 类的特点？

Record 是不可变数据类的简洁写法。

// 定义 Record
public record User(Long id, String name, String email) {
    // 紧凑构造器（校验）
    public User {
        if (name == null || name.isBlank()) {
            throw new IllegalArgumentException("Name required");
        }
    }
}

// 自动生成：构造器、getter、equals、hashCode、toString
User user = new User(1L, "Tom", "tom@example.com");
String name = user.name();  // getter 没有 get 前缀

Record 特点：

  • 隐式 final，不能被继承
  • 字段隐式 final，不可变
  • 可以实现接口，不能继承类
  • 可以定义静态方法和实例方法

Java 21 特性（重点）

Q9: 虚拟线程是什么？解决什么问题？

虚拟线程（Virtual Thread）是轻量级线程，由 JVM 调度，不与操作系统线程 1:1 绑定。

解决的问题：

  • 高并发 IO 密集型场景：传统线程数受限于 OS，虚拟线程可创建百万级
  • 简化异步编程：用同步代码风格写异步逻辑
// 创建虚拟线程
Thread vt = Thread.ofVirtual().start(() -> {
    System.out.println("Virtual Thread");
});

// 虚拟线程池
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 100_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}

// Spring Boot 3.2+ 启用虚拟线程
spring.threads.virtual.enabled=true

Q10: 虚拟线程的使用注意事项？

场景是否适合原因
IO 密集型✅ 适合阻塞时释放载体线程
CPU 密集型❌ 不适合无法释放载体线程
synchronized⚠️ 注意会 pin 住载体线程
ThreadLocal⚠️ 注意虚拟线程数量大，内存开销
// 避免在虚拟线程中使用 synchronized
// 改用 ReentrantLock
private final ReentrantLock lock = new ReentrantLock();

public void doSomething() {
    lock.lock();
    try {
        // 业务逻辑
    } finally {
        lock.unlock();
    }
}

Q11: Record Patterns 记录模式？

Java 21 支持在模式匹配中解构 Record。

record Point(int x, int y) {}
record Line(Point start, Point end) {}

// 解构 Record
if (obj instanceof Point(int x, int y)) {
    System.out.println("x=" + x + ", y=" + y);
}

// 嵌套解构
if (obj instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
    System.out.println("Line from (" + x1 + "," + y1 + ") to (" + x2 + "," + y2 + ")");
}

// switch 中使用
String desc = switch (shape) {
    case Circle(double r) -> "Circle with radius " + r;
    case Rectangle(double w, double h) -> "Rectangle " + w + "x" + h;
    default -> "Unknown shape";
};

Q12: Sequenced Collections 顺序集合？

Java 21 新增了顺序集合接口，统一了有序集合的操作。

// 新接口层次
// SequencedCollection <- List, Deque, SortedSet
// SequencedSet <- SortedSet, LinkedHashSet
// SequencedMap <- SortedMap, LinkedHashMap

List<String> list = new ArrayList<>();
list.addFirst("first");   // 新方法
list.addLast("last");     // 新方法
String first = list.getFirst();
String last = list.getLast();
List<String> reversed = list.reversed();  // 反转视图

GC 相关新特性

Q13: ZGC 和 G1 的区别？

特性G1ZGC
目标平衡吞吐和延迟超低延迟（<1ms）
停顿时间几十到几百毫秒亚毫秒级
堆大小TB 级TB 级
并发部分并发几乎完全并发
适用场景通用场景延迟敏感场景
# 启用 ZGC
java -XX:+UseZGC -Xmx16g MyApp

# 启用分代 ZGC（Java 21+，推荐）
java -XX:+UseZGC -XX:+ZGenerational -Xmx16g MyApp

小结

Java 新特性面试重点：

  1. Java 8：Lambda、Stream、Optional
  2. Java 11：var、HTTP Client
  3. Java 17：Sealed Classes、Record、Pattern Matching
  4. Java 21：虚拟线程、Record Patterns、Sequenced Collections
  5. GC：ZGC 的特点和使用场景

面试题预览

高频面试题

  1. Lambda 表达式的实现原理？
  2. Stream 的惰性求值是什么意思？
  3. 虚拟线程和平台线程的区别？
  4. 什么场景适合使用虚拟线程？
  5. Record 和普通类有什么区别？
最近更新:
贡献者: Salmon