为什么你该立即学习 Java 的 Lambda 表达式？

前言

大家好，我是不熬夜崽崽。作为一名 Java 后端研发，今天想跟大家聊的是一个老生常谈的话题，不知大家有没有过这样的经历，写代码的时候你总觉得代码中充斥着一堆匿名类，代码看上去比搞笑片还要复杂？尤其是在 Java 中，匿名类总能让你头疼不已。你是不是也觉得，这些冗长的匿名类代码就像是一个个“死结”，越绕越复杂，最后让你深陷其中，无法自拔？

如果你有过类似的经历，那么你是时候认识 Java 中的一个绝招了——Lambda 表达式。它将彻底改变你与代码打交道的方式，让你享受编程的乐趣，告别那些繁琐、复杂的写法。那么，Lambda 表达式到底是什么？为什么它会成为 Java 8 的一颗璀璨明珠？让我们一探究竟。

什么是 Lambda 表达式？

你可能已经知道，Java 之前的编程习惯是利用匿名类来实现一些接口的行为，比如线程的执行或者事件的处理。然而，这种做法会导致代码膨胀和冗长，特别是对于一些简单的操作来说，匿名类的冗余性显得尤为明显。让我们先来看看传统的写法：

传统匿名类的写法

public class Test {
    public static void main(String[] args) {
        // 使用匿名类
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程正在运行...");
            }
        });
        thread.start();
    }
}

代码解析：

Thread thread = new Thread(new Runnable() {...}); 这一行创建了一个新的线程，它接受一个 Runnable 类型的对象作为参数，这里使用的是匿名类。

匿名类中实现了 Runnable 接口，并重写了其中的 run() 方法，这个方法的内容是线程需要执行的任务。在 run() 方法中，我们打印了“线程正在运行...”。

thread.start(); 这行代码启动了新创建的线程。

然而，尽管这段代码能够正常运行，但它非常冗长，尤其是对于简单的任务，我们甚至需要为它创建一个匿名类，写很多不必要的代码。

使用 Lambda 表达式简化代码

好消息来了——Java 8 引入了 Lambda 表达式，它让这个问题迎刃而解。Lambda 表达式的基本语法非常简洁：

代码案例1

(parameters) -> expression

是不是非常简洁明了哇？？

代码解析1

(parameters) 是传递给 Lambda 表达式的参数，可以是零个或多个。例如，在我们后面的例子中传递的是 () ->，表示没有参数。

-> 是箭头操作符，表示 Lambda 表达式的开始，指向 Lambda 体。

expression 是 Lambda 表达式的主体，也就是我们要执行的代码。

代码案例2

那么，让我们用 Lambda 表达式来重写刚才的线程代码：

package com.example.javase.wf.jinshiplan.demo202505.demo5;

/**
 * @Author wf
 * @Date 2025-06-20 09:30
 */
public class Test1 {
    public static void main(String[] args) {
        // 使用 Lambda 表达式
        Thread thread = new Thread(() -> System.out.println("线程正在运行..."));
        thread.start();
    }
}

代码解析2

Thread thread = new Thread(() -> System.out.println("线程正在运行...")); 这一行，我们用 Lambda 表达式替代了匿名类，简洁明了。

() -> System.out.println("线程正在运行..."); 这里，() 表示没有传入参数，-> 表示这是 Lambda 表达式的开始，System.out.println("线程正在运行..."); 是执行的代码。

thread.start(); 和之前一样，启动了线程。

只用一行简洁的代码，我们就完成了线程的创建和启动。相比传统的匿名类写法，Lambda 表达式让代码更加简洁、可读性更强，也避免了冗长的类声明。

结果运行展示2

根据如上案例，本地实际结果运行展示如下，仅供参考：

为什么 Lambda 表达式值得学习？

1. 简化代码：让你告别冗长

Java 8 之前，很多功能的实现需要写出冗长的匿名类，这样的代码不仅难以维护，还让人难以理解。用 Lambda 表达式后，代码变得更加简洁，易于维护。你可以将复杂的逻辑直接传递给方法，减少了不必要的类定义，让代码更直观。

2. 增强可读性：更像自然语言

Lambda 表达式的语法是非常贴近自然语言的。例如，我们在集合中遍历元素时，Lambda 表达式让代码的意思更加清晰。例如，下面是使用 Lambda 表达式的代码：

java 体验AI代码助手代码解读复制代码

List<String> list = Arrays.asList("Java", "Python", "JavaScript", "C++");
list.forEach(item -> System.out.println(item));

代码解析：

List list = Arrays.asList("Java", "Python", "JavaScript", "C++"); 这里我们创建了一个包含字符串的列表。

list.forEach(item -> System.out.println(item)); 使用 forEach 方法和 Lambda 表达式遍历列表中的每个元素，并打印出来。

item -> System.out.println(item) 这是 Lambda 表达式，item 是列表中每个元素，System.out.println(item) 是对每个元素执行的操作。

一眼看去，这段代码非常直接：对列表中的每一个元素，调用 System.out.println 输出它。相比之下，使用传统方式，你可能会写出类似下面这样的代码：

for (String item : list) {
    System.out.println(item);
}

虽然这两者看起来功能上是一样的，但 Lambda 表达式的方式更加简洁，表达方式更清晰，省略了 for 循环的语法结构，让我们能更专注于业务逻辑。

3. 提高灵活性：与 Java Stream 配合使用

如果你还没有听说过 Java Stream，那么可以说你离 Java 8 的真正精髓还有一步之遥。Stream API 让集合数据的操作变得更加灵活和简洁，而 Lambda 表达式与 Stream 的结合，简直是一对黄金搭档。Stream API 是 Java 8 中引入的一个新特性，允许我们以声明式的方式来操作数据流。结合 Lambda 表达式，我们能够轻松进行数据的过滤、映射、排序等操作。

让我们来看看一个例子，如何使用 Lambda 表达式和 Stream 来操作数据：

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
        
        // 使用 Stream 和 Lambda 表达式过滤出偶数并打印
        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .collect(Collectors.toList());

        System.out.println("偶数: " + evenNumbers);
    }
}

代码解析

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9); 创建一个整数列表，包含数字 1 到 9。

numbers.stream() 将列表转换为一个 Stream，这样我们就可以使用 Stream API 对数据进行操作。

.filter(n -> n % 2 == 0) 使用 filter 方法和 Lambda 表达式筛选出所有偶数。Lambda 表达式 n -> n % 2 == 0 表示选取所有能被 2 整除的元素。

.collect(Collectors.toList()) 将过滤后的偶数收集到一个新的列表中。

System.out.println("偶数: " + evenNumbers); 打印筛选出的偶数列表。

通过结合 Lambda 和 Stream，我们能够简洁地过滤数据。这种风格不但清晰，而且提升了代码的表达能力。再也不需要那些复杂的 for 循环，取而代之的是简洁的、易懂的 Lambda 表达式。

结果运行展示

根据如上案例，本地实际结果运行展示如下，仅供参考：

4. 函数式编程：解放思想，减少副作用

Lambda 表达式不仅仅是简化代码，它还引入了函数式编程的思想。在函数式编程中，函数是第一公民，你可以像使用数据一样使用函数。这种思维方式的引入，让 Java 在一定程度上告别了面向对象编程的“副作用”，使得代码的可预测性和可测试性得到提升。

Lambda 表达式的实际应用：更轻松地与集合操作结合

集合遍历：更简洁的写法

你是否曾经为遍历一个集合而写出冗长的 for 循环？试试 Lambda 表达式吧！它让集合的操作变得更加简洁明了。例如，在遍历一个列表时，我们可以使用 forEach 方法直接传入一个 Lambda 表达式：

List<String> list = Arrays.asList("Java", "Python", "C++", "JavaScript");
list.forEach(str -> System.out.println(str));

代码解析：

List list = Arrays.asList("Java", "Python", "C++", "JavaScript"); 创建一个包含编程语言名称的列表。

list.forEach(str -> System.out.println(str)); 使用 forEach 方法和 Lambda 表达式遍历列表中的每个元素，str -> System.out.println(str) 就是 Lambda 表达式，表示对每个元素 str 执行 System.out.println(str) 操作。

数据筛选：过滤、映射更简单

Lambda 和 Stream API 结合后，可以更容易地进行数据的筛选和转换。例如，我们可以从一个学生列表中筛选出所有成绩大于 80 的学生：

测试代码展示

接着，我给大家展示下，结合理论与实战给大家把知识点讲透，案例代码如下：

package com.example.javase.wf.jinshiplan.demo202505.demo5;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author wf
 * @Date 2025-06-20 09:30
 */
public class Test2 {
    public static void main(String[] args) {
        List<Student> students = Arrays.asList(
                new Student("Tom", 85),
                new Student("Jerry", 70),
                new Student("Mickey", 90)
        );

        List<Student> passedStudents = students.stream()
                .filter(student -> student.getScore() > 80)
                .collect(Collectors.toList());
        passedStudents.forEach(student -> System.out.println(student.getName()));
    }
}

附上Student类：

package com.example.javase.wf.jinshiplan.demo202505.demo5;

/**
 * @Author wf
 * @Date 2025-06-20 09:30
 */
public class Student {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public String getName() {
        return name;
    }

    public int getScore() {
        return score;
    }
}

结果运行展示

根据如上案例，本地实际结果运行展示如下，仅供参考：

代码解析

List students = Arrays.asList(...); 创建一个学生列表，每个学生包含姓名和成绩。

students.stream() 将列表转换为 Stream，以便使用 Stream API 进行操作。

.filter(student -> student.getScore() > 80) 使用 filter 方法和 Lambda 表达式筛选出成绩大于 80 分的学生。

.collect(Collectors.toList()) 将筛选后的学生收集到一个新的列表中。

passedStudents.forEach(student -> System.out.println(student.getName())); 遍历筛选后的学生列表，并打印学生姓名。

结语：Lambda 表达式是你 Java 编程的必修课

看完这些例子后，你是不是觉得 Lambda 表达式的魅力无穷？它不仅能够让你的代码更简洁、清晰，还能引领你进入函数式编程的世界，帮助你写出更优雅、更高效的 Java 代码。

如果你还没学会 Lambda 表达式，那就赶紧投入实战使用了，它将会让你屡用屡爽，欲罢不能！反正我是自从用上了Java 8的表达式后，手上就难以戒掉。

作者：我崽不熬夜

链接：https://juejin.cn

+友情链接