当前位置：首页 > news >正文

Java8 到 Java21 系列之 Lambda 表达式：函数式编程的开端（Java 8）

news 2025/7/19 1:12:42

Java8 到 Java21 系列之 Lambda 表达式：函数式编程的开端（Java 8）

系列目录

Java8 到 Java21 系列之 Lambda 表达式：函数式编程的开端（Java 8）
Java 8 到 Java 21 系列之 Stream API：数据处理的新方式（Java 8）更新中
Java 8 到 Java 21 系列之 Optional 类型：优雅地处理空值（Java 8）更新中
Java 8 到 Java 21 系列之新日期时间 API：精确的时间管理（Java 8）更新中
Java 8 到 Java 21 系列之模块化系统：构建模块化的 Java 应用（Java 9）更新中
Java 8 到 Java 21 系列之 JShell：即时运行 Java 代码（Java 9）更新中
Java 8 到 Java 21 系列之局部变量类型推断：var 关键字的妙用（Java 10）更新中
Java 8 到 Java 21 系列之 HTTP Client API：现代网络通信的基础（Java 11）更新中
Java 8 到 Java 21 系列之 ZGC：低延迟垃圾收集器的秘密（Java 11）更新中
Java 8 到 Java 21 系列之 Switch 表达式的进化（Java 12）更新中
Java 8 到 Java 21 系列之文本块：轻松管理多行字符串（Java 13）更新中
Java 8 到 Java 21 系列之 instanceof 模式匹配：简化类型检查（Java 14）更新中
Java 8 到 Java 21 系列之 Records：数据类的全新体验（Java 14）更新中
Java 8 到 Java 21 系列之密封类：限制继承的艺术（Java 15）更新中
Java 8 到 Java 21 系列之外部函数与内存 API：无缝集成本地代码（Java 17）更新中
Java 8 到 Java 21 系列之 Sealed Classes 正式登场：增强类型安全性（Java 17）更新中
Java 8 到 Java 21 系列之强封装 JDK 内部 API：保护你的应用程序（Java 17）更新中
Java 8 到 Java 21 系列之增强的伪随机数生成器：更高质量的随机数（Java 17）更新中
Java 8 到 Java 21 系列之虚拟线程：并发编程的新纪元（Java 21）更新中
Java 8 到 Java 21 系列之分代 ZGC 优化：迈向更高性能（Java 21）更新中
Java 8 到 Java 21 系列之序列集合 API：简化集合操作（Java 21）更新中

摘要与引言

自Java 8发布以来，Lambda表达式作为其核心特性之一，标志着Java进入了函数式编程的新时代。它不仅简化了代码结构，还使得编写并发程序变得更加直观和高效。通过允许行为作为参数传递，Lambda表达式极大地减少了模板代码的数量，增强了代码的可读性和维护性。本文将深入探讨Lambda表达式的概念、语法及其在Java中的应用，并通过具体的示例展示如何利用这一强大的特性来提高开发效率。同时，我们将对比传统方法与Lambda表达式的实现，帮助读者更好地理解其优势。

Lambda表达式的概念

Lambda表达式是一种匿名函数，可以作为参数传递给方法或存储在变量中。这种特性特别适合于只有一个抽象方法的接口——即所谓的函数式接口。通过使用Lambda表达式，开发者能够更专注于业务逻辑本身，而不是繁琐的实现细节。例如，它可以用来简化集合操作、事件处理等场景，从而让代码更加简洁和易读。

Lambda表达式的语法

Lambda表达式由三个主要部分组成：

参数列表
箭头操作符 ->
主体（可以是一个表达式或语句块）

以下是几种常见的Lambda表达式形式：

1. 无参的Lambda表达式

Lambda表达式：

Runnable noArguments = () -> System.out.println("Hello World");

等价的传统方法（匿名内部类）：

Runnable noArguments = new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello World");
    }
};

2. 单个参数的Lambda表达式

Lambda表达式：

Consumer<String> singleParameter = s -> System.out.println(s);

等价的传统方法（匿名内部类）：

Consumer<String> singleParameter = new Consumer<String>() {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
};

3. 多个参数的Lambda表达式

Lambda表达式：

BinaryOperator<Long> add = (x, y) -> x + y;

等价的传统方法（匿名内部类）：

BinaryOperator<Long> add = new BinaryOperator<Long>() {
    @Override
    public Long apply(Long x, Long y) {
        return x + y;
    }
};

4. 带语句块的Lambda表达式

Lambda表达式：

BinaryOperator<Integer> addWithBlock = (x, y) -> {
    int sum = x + y;
    return sum;
};

等价的传统方法（匿名内部类）：

BinaryOperator<Integer> addWithBlock = new BinaryOperator<Integer>() {
    @Override
    public Integer apply(Integer x, Integer y) {
        int sum = x + y;
        return sum;
    }
};

实际应用案例与传统方法对比

示例1：创建线程

/**
 * Lambda表达式单元测试案例
 *
 * @author JunLiang
 */
@DisplayName("Lambda表达式单元测试案例")
public class LambdaTest {

    @DisplayName("测试Lambda创建线程")
    @Test
    public void threadTest(){
        // 使用匿名内部类创建线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("传统方法!");
            }
        }).start();

        // 使用Lambda表达式创建线程
        new Thread(() -> System.out.println("Lambda表达式!")).start();
    }
}

在这里插入图片描述

对比：

传统方法需要显式地定义匿名内部类，代码冗长且不够直观。
Lambda表达式仅需一行代码即可完成相同功能，显著提高了可读性和简洁性。

示例2：集合数据处理

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * Lambda表达式单元测试案例
 *
 * @author JunLiang
 */
@DisplayName("Lambda表达式单元测试案例")
public class LambdaTest {

   @DisplayName("测试Lambda表达式排序")
    @Test
    public void sortTest(){
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee("Alice", 35, 75000));
        employees.add(new Employee("Bob", 28, 60000));
        employees.add(new Employee("Charlie", 40, 90000));
        employees.add(new Employee("David", 32, 80000));
        employees.add(new Employee("Eve", 25, 50000));

        System.out.println("传统方法：");
        // 过滤年龄大于30的员工
        List<Employee> filtered = new ArrayList<>();
        for (Employee employee : employees) {
            if (employee.getAge() > 30) {
                filtered.add(employee);
            }
        }

        // 按工资从高到低排序
        Collections.sort(filtered, new Comparator<Employee>() {
            @Override
            public int compare(Employee e1, Employee e2) {
                return Double.compare(e2.getSalary(), e1.getSalary());
            }
        });

        // 提取并打印名字
        for (Employee employee : filtered) {
            System.out.println(employee.getName());
        }

        System.out.println("\nLambda表达式：");

        // 使用Lambda表达式和Stream API处理数据
        List<String> result = employees.stream()
            .filter(employee -> employee.getAge() > 30)
            .sorted((e1, e2) -> Double.compare(e2.getSalary(), e1.getSalary()))
            .map(Employee::getName)
            .collect(Collectors.toList());

        // 输出结果
        result.forEach(System.out::println);
    }

    class Employee {
        private String name;
        private int age;
        private double salary;

        public Employee(String name, int age, double salary) {
            this.name = name;
            this.age = age;
            this.salary = salary;
        }

        public String getName() { return name; }
        public int getAge() { return age; }
        public double getSalary() { return salary; }
    }
}

测试结果如下：
在这里插入图片描述

对比：

传统方法需要手动遍历集合进行过滤和排序，代码量大且容易出错。
Lambda表达式结合Stream API，以声明式的方式完成复杂的数据处理任务，代码简洁、逻辑清晰。

结论

Lambda表达式是Java 8中最重要的新特性之一，开启了Java编程的新篇章。通过提供更简洁的语法和更强的表达能力，对于企业级应用来说，Lambda表达式的引入极大地提高了开发效率，降低了维护成本。它通过减少冗余代码，增强了代码的可读性和可维护性。Lambda表达式帮助开发者编写更加优雅和高效的代码。无论是简单的线程创建还是复杂的数据处理任务，Lambda表达式都能显著提升开发体验。随着Java版本的不断演进，Lambda表达式将在未来的版本中继续发挥重要作用，成为现代Java应用不可或缺的一部分。

查看全文

http://www.dtcms.com/a/107492.html