啃透 Java 8：JDK1.8新特性面试清单与实战避坑指南

内容摘要：啃透 Java 8：JDK1.8新特性面试清单与实战避坑指南,

很多 Java 开发者在面试时，面对关于 JDK1.8新特性 的提问，往往只能泛泛而谈，无法深入到原理和实际应用。例如，被问到 Lambda 表达式和 Stream API 的优势，只会说“代码更简洁”，而说不出背后的性能优化和设计思想。本文将通过通俗的生活案例和深度理解，帮你彻底掌握 Java 8 的新特性，轻松应对面试。

Lambda 表达式：让代码像说话一样自然

什么是 Lambda 表达式？

Lambda 表达式本质上是一个匿名函数，可以作为参数传递给方法，或者作为方法返回值。它简化了函数式接口的实现，使代码更加简洁易读。

生活案例：

想象一下，你要去饭店点菜。传统的点菜方式是，你告诉服务员：“我要一份宫保鸡丁，不要辣椒，多放花生。” 这就像传统的匿名内部类，你需要创建一个对象，然后重写方法，才能表达你的意图。

而使用 Lambda 表达式，你可以直接说：“宫保鸡丁 -> 不要辣椒, 多放花生”。 这更直接，更自然。

Lambda 表达式的语法

Lambda 表达式的语法如下：

(parameters) -> expression
或
(parameters) -> { statements; }

示例：

// 无参数的 Lambda 表达式
() -> System.out.println("Hello, Lambda!");

// 带有单个参数的 Lambda 表达式
(String name) -> System.out.println("Hello, " + name);

// 带有多个参数的 Lambda 表达式
(int a, int b) -> a + b;

函数式接口：Lambda 表达式的载体

函数式接口是指只有一个抽象方法的接口。Java 8 提供了 @FunctionalInterface 注解来标识函数式接口。如果一个接口只有一个抽象方法，编译器会自动将其识别为函数式接口。

示例：

@FunctionalInterface
interface MyInterface {
    void myMethod();
}

实战：使用 Lambda 表达式简化排序

传统的排序方式：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.compareTo(o2);
    }
});

使用 Lambda 表达式简化排序：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
names.sort((o1, o2) -> o1.compareTo(o2)); // 使用 Lambda 表达式

避坑经验：类型推断和空指针异常

• 类型推断： Lambda 表达式可以省略参数类型，编译器会自动进行类型推断。但如果编译器无法推断出类型，则需要显式指定类型。
• 空指针异常： 在使用 Lambda 表达式时，要注意避免空指针异常。例如，如果 Lambda 表达式中使用了外部变量，要确保该变量不为空。

Stream API：高效的数据处理管道

什么是 Stream API？

Stream API 提供了一种声明式的方式来处理集合数据。它可以将数据源转换成一个 Stream，然后通过一系列中间操作（如 filter、map、sort）和终端操作（如 collect、forEach、count）来处理数据。

生活案例：

你可以把 Stream API 想象成一条流水线。原料（数据）进入流水线，经过一系列加工（中间操作），最终得到成品（结果）。

Stream API 的优势

• 简洁： 使用 Stream API 可以用更少的代码完成复杂的数据处理任务。
• 高效： Stream API 内部使用了并行处理，可以充分利用多核 CPU 的优势，提高处理效率。
• 延迟执行： Stream API 的中间操作是延迟执行的，只有在执行终端操作时才会触发计算。

Stream API 的常用操作

• filter()：过滤数据
• map()：转换数据
• sort()：排序数据
• collect()：收集结果
• forEach()：遍历数据
• count()：统计数量

示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// 过滤出偶数，并计算它们的平方和
int sum = numbers.stream()
               .filter(n -> n % 2 == 0)  // 过滤偶数
               .map(n -> n * n)         // 计算平方
               .reduce(0, Integer::sum); // 求和

System.out.println("Sum of squares of even numbers: " + sum);

实战：使用 Stream API 进行数据分析

假设你有一个包含用户数据的 List，你想统计年龄大于 18 岁的用户数量：

List<User> users = new ArrayList<>();
users.add(new User("Alice", 20));
users.add(new User("Bob", 17));
users.add(new User("Charlie", 25));
users.add(new User("David", 19));

long count = users.stream()
               .filter(user -> user.getAge() > 18)
               .count();

System.out.println("Number of users older than 18: " + count);

class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

避坑经验：并行流的线程安全问题

• 线程安全： 在使用并行流时，要注意线程安全问题。如果 Stream 的操作涉及到共享变量的修改，需要使用线程安全的集合或同步机制。
• 性能损耗： 并行流并非总是更快。对于数据量较小的集合，并行流可能会因为线程切换和数据同步而产生额外的性能损耗。

Optional 类：优雅地处理空指针异常

什么是 Optional 类？

Optional 类是一个容器类，可以包含一个非空对象，也可以为空。它可以帮助我们避免空指针异常，并使代码更加健壮。

生活案例：

你准备去取快递。快递员告诉你，你的快递可能已经到了，也可能还没有到。Optional 类就像一个快递柜，它可以包含你的快递（非空对象），也可以是空的（没有快递）。

Optional 类的常用方法

• of()：创建一个包含指定值的 Optional 对象。
• ofNullable()：创建一个可以包含空值的 Optional 对象。
• isPresent()：判断 Optional 对象是否包含值。
• get()：获取 Optional 对象包含的值。如果 Optional 对象为空，则抛出 NoSuchElementException 异常。
• orElse()：如果 Optional 对象为空，则返回指定的默认值。
• orElseGet()：如果 Optional 对象为空，则返回一个由 Supplier 函数生成的值。
• orElseThrow()：如果 Optional 对象为空，则抛出一个指定的异常。

示例：

String name = null;

// 使用 Optional 类处理空指针异常
Optional<String> optionalName = Optional.ofNullable(name);

// 如果 name 为空，则返回默认值 "Unknown"
String result = optionalName.orElse("Unknown");

System.out.println("Name: " + result);

实战：使用 Optional 类处理返回值

public Optional<User> findUserById(int id) {
    // 假设从数据库中查找用户
    User user = null; // 假设没有找到用户
    return Optional.ofNullable(user);
}

// 使用 Optional 类处理返回值
Optional<User> user = findUserById(123);

if (user.isPresent()) {
    System.out.println("User found: " + user.get().getName());
} else {
    System.out.println("User not found");
}

避坑经验：过度使用 Optional 类

• 过度使用： 不要过度使用 Optional 类。Optional 类主要用于处理可能为空的返回值，对于其他场景，使用 Optional 类可能会增加代码的复杂性。
• 序列化问题： Optional 类本身不是可序列化的。如果需要在网络上传输 Optional 对象，需要进行特殊处理。

Date/Time API (JSR-310)：更易用的日期时间处理

Java 8 引入了新的 Date/Time API，解决了旧的 java.util.Date 和 java.util.Calendar 类的诸多问题，例如线程安全问题、API 设计不合理等。

核心类

• LocalDate：表示日期，例如 2023-10-27。
• LocalTime：表示时间，例如 10:30:00。
• LocalDateTime：表示日期和时间，例如 2023-10-27T10:30:00。
• ZonedDateTime：表示带时区的日期和时间。
• Duration：表示时间段，例如 2 小时 30 分钟。
• Period：表示日期段，例如 3 年 2 个月 1 天。

示例

// 获取当前日期
LocalDate today = LocalDate.now();
System.out.println("Today: " + today);

// 格式化日期
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
String formattedDate = today.format(formatter);
System.out.println("Formatted date: " + formattedDate);

// 计算两个日期之间的间隔
LocalDate birthday = LocalDate.of(1990, 1, 1);
Period period = Period.between(birthday, today);
System.out.println("Age: " + period.getYears() + " years, " + period.getMonths() + " months, " + period.getDays() + " days");

与旧API的兼容

Java 8 提供了与旧 API 的兼容性。可以使用 java.util.Date.toInstant() 方法将 Date 对象转换为 Instant 对象，然后可以使用 Instant.atZone() 方法将其转换为 ZonedDateTime 对象。

避坑经验

• 时区问题：涉及到全球化应用，必须深刻理解时区的概念，并正确使用 ZonedDateTime 类。
• 线程安全：LocalDate, LocalTime, LocalDateTime 等类是不可变的，因此是线程安全的。

方法引用：更简洁的 Lambda 表达式

方法引用是 Lambda 表达式的一种简化写法，它可以直接引用已经存在的方法。

示例

// Lambda 表达式
List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.forEach(name -> System.out.println(name));

// 方法引用
names.forEach(System.out::println); // 方法引用

避坑经验

• 适用场景：方法引用主要用于 Lambda 表达式只是简单地调用一个已经存在的方法的场景。
• 类型匹配：方法引用的参数类型和返回值类型必须与函数式接口的抽象方法兼容。

掌握了以上 JDK1.8新特性，相信你就能在面试中游刃有余，轻松应对各种关于 Java 8 的问题。记住，理解原理，结合实际案例，才能真正掌握这些强大的特性。