Java 函数式编程入门：Lambda 表达式

最新推荐文章于 2025-11-30 18:24:05 发布

原创最新推荐文章于 2025-11-30 18:24:05 发布 · 1.1k 阅读

17 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

JAVA 专栏收录该内容

46 篇文章

订阅专栏

在 Java 编程中，代码的简洁性和可读性一直是开发者追求的目标。JDK8 引入的 Lambda 表达式，为我们带来了函数式编程的思想，让代码变得更加简洁直观。本文将通过实例带你理解 Lambda 表达式的本质、用法及简化规则，感受函数式编程的魅力。

一、为什么需要 Lambda 表达式？—— 从匿名内部类的痛点说起

在面向对象编程中，当我们需要传递一个接口的实现类对象（且该对象仅使用一次）时，通常会采用匿名内部类的方式。例如定义一个Swim接口，并用匿名内部类实现其方法：

// 函数式接口
@FunctionalInterface
interface Swim {
    void swimming();
}

// 匿名内部类调用
public static void main(String[] args) {
    method(new Swim() {
        @Override
        public void swimming() {
            System.out.println("正在游泳");
        }
    });
}

public static void method(Swim s) {
    s.swimming();
}

这段代码的核心逻辑是System.out.println("正在游泳")，但为了实现这个逻辑，我们不得不写大量模板代码（new Swim() {}、@Override等）。当接口方法简单时，这些模板代码会显得冗余且可读性差。

而 Lambda 表达式的出现，正是为了简化这种场景的代码书写，让我们专注于 “做什么”，而非 “怎么实现”。

二、Lambda 表达式的基础：格式与核心思想

1. Lambda 表达式的格式

Lambda 表达式的基本结构可以概括为：

(参数列表) -> { 方法体 }

(参数列表)：对应接口中抽象方法的形参，无需声明参数类型（可推导）
->：箭头符号，用于连接参数列表和方法体
{ 方法体 }：对应接口中抽象方法的实现逻辑

2. 核心思想：函数式编程

面向对象编程强调 “找对象，让对象做事情”，而函数式编程思想更关注 “做什么，而非谁去做”。Lambda 表达式正是这种思想的体现：它忽略了对象创建的复杂语法，直接传递方法的实现逻辑。

例如，用 Lambda 表达式改写上面的匿名内部类调用：

// Lambda表达式完整格式
method(() -> {
    System.out.println("正在游泳");
});

相比匿名内部类，代码瞬间简洁了许多 —— 我们不再需要写new Swim()和@Override，直接聚焦于swimming()方法的核心逻辑。

三、Lambda 表达式的使用前提：函数式接口

Lambda 表达式只能简化函数式接口的匿名内部类写法，这是使用的核心前提。

函数式接口：有且仅有一个抽象方法的接口（可以包含默认方法、静态方法等）。
可通过@FunctionalInterface注解标记接口，编译器会自动校验该接口是否符合函数式接口规范。

例如：

@FunctionalInterface // 校验是否为函数式接口
interface Swim {
    void swimming(); // 唯一的抽象方法
    // 可以有默认方法或静态方法
    default void test() {} 
}

四、Lambda 表达式的简化规则：可推导，可省略

Lambda 表达式的简化核心是 “可推导的内容都可以省略”，具体规则如下：

参数类型可省略
接口方法的参数类型可以根据上下文自动推导，无需显式声明。
例如：(String o1, String o2) -> { ... } 可简化为 (o1, o2) -> { ... }
单参数时，括号可省略
若接口方法只有一个参数，不仅可以省略类型，还能省略参数外侧的括号。
例如：(s) -> { System.out.println(s); } 可简化为 s -> { System.out.println(s); }
方法体单行时，简化大括号、分号和 return
若方法体只有一行代码，可同时省略{}、;，若有 return 也需一并省略。
例如：(o1, o2) -> { return o1.length() - o2.length(); } 可简化为 (o1, o2) -> o1.length() - o2.length()

五、实战案例：用 Lambda 表达式简化排序逻辑

以字符串数组排序为例，演示 Lambda 表达式的简化过程。需求：按字符串长度从小到大排序。

1. 匿名内部类实现

String[] arr = {"a", "aaaa", "aaa", "aa"};
// 使用Comparator接口的匿名内部类指定排序规则
Arrays.sort(arr, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return o1.length() - o2.length(); // 按长度排序
    }
});
System.out.println(Arrays.toString(arr)); // [a, aa, aaa, aaaa]

2. Lambda 表达式完整格式

Arrays.sort(arr, (String o1, String o2) -> {
    return o1.length() - o2.length();
});

3. 逐步简化

省略参数类型：(o1, o2) -> { return o1.length() - o2.length(); }
省略方法体大括号、分号和 return：(o1, o2) -> o1.length() - o2.length()

最终简化后的代码：

Arrays.sort(arr, (o1, o2) -> o1.length() - o2.length());

一行代码即可完成排序规则的定义，相比匿名内部类，可读性和简洁性大幅提升。

六、总结：Lambda 表达式的价值

Lambda 表达式并非语法糖，而是 Java 对函数式编程思想的支持。它的核心价值在于：

简化代码：消除匿名内部类的模板代码，让核心逻辑更突出；
聚焦逻辑：强调 “做什么” 而非 “怎么实现”，符合函数式编程思想；
提升可读性：对于简单逻辑，Lambda 表达式比匿名内部类更易理解。

掌握 Lambda 表达式，不仅能让代码更优雅，也能为后续学习 Stream API 等高级特性打下基础。