【Java进阶】Lambda、Stream、Optional还没用熟？带你深入底层，展望Project Loom未来！告别臃肿代码！-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_57361509/article/details/148493670

文章目录

📖 前言：Java，还在焕发新春！

Java，作为一门经久不衰的编程语言，并没有停滞不前。从Java 8开始，它引入了一系列革命性的新特性，极大地改变了我们的编程方式，使代码更加简洁、可读性更高、并发处理更优雅。如今，Java的生态依然在飞速发展，Project Loom等前沿项目预示着更加光明的未来。

你是否还在为冗长且容易出错的匿名内部类而头疼？是否还在用循环处理集合，效率低下且代码臃肿？是否还在为恼人的NullPointerException而夜不能寐？

如果你的答案是“是”，那么恭喜你，来对地方了！本文将带你深入浅出地掌握Java 8的核心新特性——Lambda表达式、Stream API、Optional，并一起展望Project Loom将为Java并发编程带来的颠覆性变革。准备好了吗？让我们一起开启这场Java进阶之旅！

🚀 第一站：Lambda表达式 - 代码瘦身的魔法师

还记得那些为了实现一个简单接口而不得不写的匿名内部类吗？冗长、模板化，看着就心累。Lambda表达式的出现，就是为了解放我们！

1. 什么是Lambda表达式？

Lambda表达式，简单来说，是一个可传递的匿名函数。它允许我们将函数作为参数传递，或者返回一个函数作为结果。它没有名称，但有参数列表、函数体、返回类型，可能还会抛出异常。

核心思想： 关注“做什么”（What to do），而不是“怎么做”（How to do it with objects）。

2. Lambda表达式的语法

基本语法：(parameters) -> expression 或 (parameters) -> { statements; }

参数列表 (parameters)：
- 可以为空：() -> System.out.println("Hello Lambda!")
- 单个参数可以省略括号：name -> System.out.println("Hello, " + name)
- 多个参数用逗号分隔：(a, b) -> a + b
- 参数类型可以显式声明，也可由编译器推断：(String s) -> s.length() 或 s -> s.length()
箭头 ->： 分隔参数和Lambda体。
Lambda体 expression 或 { statements; }：
- 如果只有一条语句，且是表达式，可以省略花括号{}和return关键字，表达式的值即为返回值。
  (a, b) -> a + b
- 如果包含多条语句，需要用花括号{}包裹，并且如果需要返回值，必须使用return语句。
```
(a, b) -> {
    int sum = a + b;
    System.out.println("Sum: " + sum);
    return sum;
}
```

3. 函数式接口 (Functional Interface)

Lambda表达式能够赋给的变量类型，必须是函数式接口类型。

定义： 只包含一个抽象方法的接口。
@FunctionalInterface注解： 推荐使用此注解标记函数式接口，编译器会进行检查。如果接口不符合函数式接口的定义，编译器会报错。
Java内置的函数式接口： java.util.function包下提供了大量常用的函数式接口，如：
- Predicate<T>: T -> boolean (断言，判断)
- Consumer<T>: T -> void (消费，处理)
- Function<T, R>: T -> R (转换，映射)
- Supplier<T>: () -> T (供给，创建)
- UnaryOperator<T>: T -> T (一元操作)
- BinaryOperator<T>: (T, T) -> T (二元操作)

示例：使用Lambda简化Runnable

// Java 8 之前
new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Old way Thread running...");
    }
}).start();

// Java 8 Lambda
new Thread(() -> System.out.println("Lambda Thread running...")).start();

是不是瞬间清爽了很多？

4. Lambda表达式的优势

代码简洁： 大幅减少样板代码。
易于并行处理： Lambda表达式和Stream API结合，能更方便地利用多核CPU。
可读性（习惯后）： 对于熟悉函数式编程的开发者来说，Lambda能更清晰地表达意图。

🌌 第二站：Stream API - 集合操作的瑞士军刀

处理集合数据是日常开发中最常见的任务之一。传统的for循环或迭代器方式，代码冗长，且不易并行。Stream API的出现，彻底改变了Java集合的处理方式，让我们能够以一种声明式、更函数式的方式操作数据。

1. 什么是Stream API？

Stream API并不是一种数据结构，它不存储数据。它更像是一个高级迭代器，可以让你以流水线的方式处理数据源（如集合、数组等）中的元素。

核心特点：

元素序列： Stream看作是一系列元素的有序（或无序）序列。
数据源： 可以是集合、数组、I/O通道等。
聚合操作： 支持类似SQL的操作，如filter, map, reduce, find, match, sorted等。
流水线操作： 多个操作可以链接起来形成一个复杂的流水线。
内部迭代： 与外部迭代（显式使用Iterator或for-each）不同，Stream API使用内部迭代，由库来处理迭代细节。
延迟执行（惰性求值）： 中间操作（如filter, map）不会立即执行，只有当终端操作（如forEach, collect）被调用时，整个流水线才会开始执行。
一次性消费： Stream只能被消费一次。一旦消费完毕，就不能再被使用。

2. Stream的创建

从集合创建：

List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream(); // 顺序流
Stream<String> parallelStream = list.parallelStream(); // 并行流

从数组创建：

String[] array = {"x", "y", "z"};
Stream<String> stream = Arrays.stream(array);

使用Stream.of()：

Stream<String> stream = Stream.of("apple", "banana", "cherry");

使用Stream.iterate() 和 Stream.generate() (创建无限流)：

Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 2); // 0, 2, 4, ...
Stream<Double> randomStream = Stream.generate(Math::random);
// 无限流通常需要配合 limit() 等中间操作使用

3. Stream的常用操作

Stream操作分为两类：

中间操作 (Intermediate Operations):
- 返回一个新的Stream，可以链式调用。
- 惰性执行。
- 常用方法：
  - filter(Predicate<T> predicate): 过滤元素。
  - map(Function<T, R> mapper): 转换元素。
  - flatMap(Function<T, Stream<R>> mapper): 将每个元素转换为一个Stream，然后将所有这些Stream连接成一个Stream (扁平化)。
  - distinct(): 去重。
  - sorted() / sorted(Comparator<T> comparator): 排序。
  - peek(Consumer<T> action): 对每个元素执行操作，主要用于调试。
  - limit(long maxSize): 截断流，使其元素不超过给定数量。
  - skip(long n): 跳过前n个元素。
终端操作 (Terminal Operations):
- 触发实际计算，产生一个结果或副作用。
- 一个Stream只能有一个终端操作。
- 常用方法：
  - forEach(Consumer<T> action): 遍历每个元素。
  - count(): 返回元素个数。
  - collect(Collector<T, A, R> collector): 将流转换为其他形式（如List, Set, Map）。
```
List<String> filteredList = names.stream()
                                 .filter(s -> s.startsWith("A"))
                                 .collect(Collectors.toList());
Map<Integer, List<String>> mapByLength = names.stream()
                                              .collect(Collectors.groupingBy(String::length));
```
  - reduce(BinaryOperator<T> accumulator) / reduce(T identity, BinaryOperator<T> accumulator): 将流中的元素规约为一个值。
```
Optional<Integer> sum = numbers.stream().reduce((a, b) -> a + b);
int product = numbers.stream().reduce(1, (a, b) -> a * b);
```
  - anyMatch(Predicate<T> predicate): 是否至少有一个元素匹配。
  - allMatch(Predicate<T> predicate): 是否所有元素都匹配。
  - noneMatch(Predicate<T> predicate): 是否没有元素匹配。
  - findFirst(): 返回第一个元素 (Optional)。
  - findAny(): 返回任意一个元素 (Optional)，在并行流中性能更好。
  - toArray(): 转换为数组。

4. Stream API实战示例

假设我们有一个Person类：

class Person {
    String name;
    int age;
    String city;
    // constructor, getters, setters, toString
}

现在有一组Person对象，我们想找出所有来自"Beijing"且年龄大于18岁的人的姓名，并按年龄排序。

传统方式：

List<Person> people = ... ; // 初始化
List<String> names = new ArrayList<>();
// 1. 过滤和排序 (可能需要先排序再过滤，或过滤后排序，逻辑复杂)
List<Person> filteredPeople = new ArrayList<>();
for (Person p : people) {
    if ("Beijing".equals(p.getCity()) && p.getAge() > 18) {
        filteredPeople.add(p);
    }
}
Collections.sort(filteredPeople, new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return Integer.compare(o1.getAge(), o2.getAge());
    }
});
// 2. 提取姓名
for (Person p : filteredPeople) {
    names.add(p.getName());
}

Stream API方式：

List<Person> people = ... ; // 初始化
List<String> names = people.stream()                                 // 1. 获取Stream
                             .filter(p -> "Beijing".equals(p.getCity())) // 2. 过滤城市
                             .filter(p -> p.getAge() > 18)            // 3. 过滤年龄
                             .sorted(Comparator.comparingInt(Person::getAge)) // 4. 按年龄排序
                             .map(Person::getName)                    // 5. 提取姓名
                             .collect(Collectors.toList());             // 6. 收集结果

代码是不是简洁、流畅了许多？可读性也大大增强，一眼就能看出操作的意图。

5. 并行流 (Parallel Streams)

Stream API可以轻松地将顺序流转换为并行流，利用多核处理器的优势来加速某些操作。

long count = people.parallelStream()
                   .filter(p -> p.getAge() > 30)
                   .count();

注意：

并非所有操作都适合并行处理。对于CPU密集型操作，并行流可能带来性能提升。
对于小数据集或I/O密集型操作，并行流的线程调度开销可能超过其带来的好处。
并行流共享同一个ForkJoinPool.commonPool()，注意线程池大小和任务性质。
确保操作是无状态的、可并行的，避免共享可变状态导致线程安全问题。

✨ 第三站：Optional - 优雅处理NullPointerException

NullPointerException (NPE) 是Java程序员最头疼的异常之一。Optional<T> 是Java 8引入的一个容器类，代表一个值存在或不存在。它的目的是更优雅地处理可能为null的情况，避免显式的null检查，从而减少NPE。

1. 为什么需要Optional？

传统的null检查：

String userName = getUserNameById(id);
if (userName != null) {
    System.out.println(userName.toUpperCase());
} else {
    System.out.println("User not found");
}

这种代码随处可见，既繁琐又容易遗漏。

2. 创建Optional对象

Optional.of(T value): 创建一个包含给定非null值的Optional。如果value为null，会抛出NullPointerException。
Optional.ofNullable(T value): 创建一个Optional，如果value非null，则包含该值；如果value为null，则创建一个空的Optional。这是最常用的创建方式。
Optional.empty(): 创建一个空的Optional。

Optional<String> nameOpt1 = Optional.of("Alice");
// Optional<String> nameOpt2 = Optional.of(null); // 会抛NPE
Optional<String> nameOpt3 = Optional.ofNullable(null); // 安全，得到 Optional.empty()
Optional<String> emptyOpt = Optional.empty();

3. 使用Optional获取值

isPresent(): 判断Optional是否包含值。
get(): 如果Optional包含值，则返回值；否则抛出NoSuchElementException。不推荐直接使用，除非你确定值存在。
orElse(T other): 如果Optional包含值，则返回值；否则返回指定的默认值other。
```
String name = nameOpt.orElse("Guest");
```
orElseGet(Supplier<? extends T> other): 如果Optional包含值，则返回值；否则执行Supplier函数并返回其结果。Supplier只在Optional为空时才会被调用（惰性）。
```
String name = nameOpt.orElseGet(() -> getDefaultUserName());
```
orElseThrow(Supplier<? extends X> exceptionSupplier): 如果Optional包含值，则返回值；否则抛出由Supplier创建的异常。
```
String name = nameOpt.orElseThrow(() -> new IllegalArgumentException("Name not found"));
```

4. Optional的链式操作

Optional也支持类似Stream的函数式方法：

map(Function<? super T, ? extends U> mapper): 如果Optional包含值，则对该值应用mapper函数，并返回一个新的Optional包装的结果（如果mapper返回null，则返回Optional.empty()）。如果Optional为空，则返回Optional.empty()。
```
Optional<Integer> lengthOpt = nameOpt.map(String::length);
```

flatMap(Function<? super T, Optional<U>> mapper): 与map类似，但要求mapper函数返回一个Optional。这用于处理嵌套的Optional情况，避免Optional<Optional<T>>。

// 假设 getUserProfile(String name) 返回 Optional<UserProfile>
// UserProfile 有一个 getEmail() 方法返回 Optional<String>
Optional<String> emailOpt = nameOpt.flatMap(this::getUserProfile)
                                  .flatMap(UserProfile::getEmail);

filter(Predicate<? super T> predicate): 如果Optional包含值并且该值满足predicate，则返回该Optional；否则返回Optional.empty()。

5. Optional使用建议与误区

不要用Optional作为方法参数或类的字段类型： 这通常会增加不必要的复杂性。Optional主要设计为方法的返回类型，用于明确表示一个结果可能不存在。
避免optional.get()的滥用： 如果你用了optional.isPresent()之后紧接着optional.get()，那和传统的null检查没太大区别。尽量使用orElse, orElseGet, map等方法。
适度使用： 不是所有可能为null的地方都需要用Optional包装。它更适用于那些“值不存在是正常情况”的场景。

优雅示例：

// 获取用户配置，如果不存在则使用默认配置
public Configuration getUserConfig(String userId) {
    return findUserConfig(userId) // 返回 Optional<Configuration>
           .orElse(Configuration.DEFAULT_CONFIG);
}

// 获取用户名的长度，如果用户名不存在或为空，则返回0
public int getUserNameLength(Optional<User> userOpt) {
    return userOpt.map(User::getName)    // Optional<String>
                  .map(String::length) // Optional<Integer>
                  .orElse(0);
}

🔮 第四站：展望未来 - Project Loom 与虚拟线程

Java的进化并未止步于Java 8。在并发编程领域，一个备受期待的重大进展就是Project Loom，它旨在为Java引入轻量级的用户态线程，即虚拟线程 (Virtual Threads)，之前也被称为纤程 (Fibers)。

1. 当前并发模型的痛点

传统的Java线程（平台线程，Platform Threads）是直接映射到操作系统内核线程的。这意味着：

资源消耗大： 每个线程都需要分配独立的栈空间（通常1MB左右），创建和销毁线程的开销较大。
数量受限： 由于资源限制，一个JVM能创建的平台线程数量有限（几千到几万个）。
阻塞代价高： 当一个平台线程因I/O操作（如网络请求、文件读写）而阻塞时，它占用的系统资源（如内存、内核线程）无法被其他任务使用，导致资源浪费和吞吐量瓶颈。

这种模型在处理大量并发、I/O密集型任务时（如微服务、Web服务器）显得捉襟见肘。虽然NIO和异步编程（如CompletableFuture, RxJava, Netty）能在一定程度上缓解这个问题，但它们通常会带来更高的编程复杂度。

2. Project Loom的核心：虚拟线程

Project Loom的目标是通过引入虚拟线程来简化高并发、高吞吐量应用的开发。

轻量级： 虚拟线程不由操作系统直接管理，而是由JVM在用户态进行调度。它们的创建和上下文切换开销极小，栈空间也更小且可动态调整。
数量巨大： 一个JVM可以轻松创建数百万个虚拟线程。
阻塞不昂贵： 当虚拟线程执行一个阻塞I/O操作时，它不会阻塞底层的平台线程。JVM会将这个虚拟线程“挂起”(unmount)，并允许底层的平台线程去执行其他虚拟线程。当I/O操作完成时，虚拟线程会被“唤醒”(mount)并继续执行。

这意味着什么？
我们可以用同步阻塞的编程风格（简单直观，易于理解和调试）来编写高并发代码，而无需担心线程数量的限制和阻塞带来的性能问题。即“一个请求一个虚拟线程”的模型将变得可行且高效。

// 想象中的未来代码 (Project Loom 已在JDK 19+ 中作为预览特性提供)
// JDK 21 后正式可用
void handleRequest(Request request, Response response) {
    // 每个请求都在一个新的虚拟线程中处理
    Thread.startVirtualThread(() -> {
        String data1 = blockingCallToServiceA(request.getId()); // 阻塞，但不阻塞平台线程
        String data2 = blockingCallToServiceB(data1);          // 阻塞，但不阻塞平台线程
        response.send(process(data2));
    });
}

上面的代码看起来是同步阻塞的，但在Loom的支持下，它可以高效地处理大量并发请求。

3. Project Loom带来的影响

简化并发编程： 回归简单、顺序的编程模型，降低心智负担。
提升应用吞吐量： 特别是对于I/O密集型应用，可以显著提高并发处理能力和资源利用率。
兼容现有生态： 虚拟线程与java.lang.Thread API兼容，现有的大部分并发工具和库（如ExecutorService）可以无缝或稍作修改地支持虚拟线程。
对现有框架的影响： 像Tomcat、Jetty、Netty这类网络服务器和框架，可能会基于Loom进行架构调整，以充分利用虚拟线程的优势。

4. 如何体验和学习？

Project Loom中的虚拟线程已经在JDK 19作为预览特性引入，并在JDK 21中正式发布。你可以下载最新的JDK版本进行体验。

// JDK 21+
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 100_000; i++) {
        int taskNumber = i;
        executor.submit(() -> {
            System.out.println("Running task " + taskNumber + " on " + Thread.currentThread());
            try {
                Thread.sleep(1000); // 模拟阻塞操作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });
    }
} // executor.close() 会等待所有任务完成