Java 学习系列（11）：Java Lambda 表达式与函数式编程

原创于 2025-03-09 17:51:22 发布 · 709 阅读

11 ·

CC 4.0 BY-SA版权

文章标签：

#java #学习 #开发语言

Java学习系列专栏收录该内容

15 篇文章

订阅专栏

Java 学习系列（11）：Java Lambda 表达式与函数式编程

1. Lambda 表达式概述

Lambda 表达式是 Java 8 引入的一种新特性，它允许我们将函数作为参数传递给方法或将其作为返回值。Lambda 表达式使得 Java 编程更具简洁性和可读性，特别是在函数式编程风格中，能够让我们更轻松地处理集合、流、事件等。

Lambda 表达式的基本语法如下：

(parameters) -> expression

1.1 Lambda 表达式的组成

参数列表：可以有一个或多个参数，类型可以省略（编译器可以推断）。
箭头 ->：分隔参数和 Lambda 表达式的主体。
表达式主体：可以是一个表达式或语句块。

2. Lambda 表达式的使用

2.1 简单示例

public class LambdaExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Runnable 接口
        Runnable task = () -> System.out.println("Hello, Lambda!");
        task.run();  // 输出：Hello, Lambda!
    }
}

2.2 带参数的 Lambda 表达式

public class LambdaExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现加法操作
        MathOperation add = (a, b) -> a + b;
        System.out.println("Sum: " + add.operation(5, 3));  // 输出：Sum: 8
    }
    
    interface MathOperation {
        int operation(int a, int b);
    }
}

3. 高级 Lambda 表达式应用

3.1 使用 Lambda 表达式和集合

Lambda 表达式常常与集合操作（如 forEach、map、filter 等）一起使用，让集合处理更加简洁。

import java.util.*;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "Python", "C++", "JavaScript");

        // 使用 Lambda 表达式遍历集合
        list.forEach(item -> System.out.println(item));
    }
}

3.2 使用 Lambda 表达式和流（Streams）

Java 8 引入了流（Streams）API，可以通过 Lambda 表达式更加优雅地处理集合数据。

import java.util.*;
import java.util.stream.*;

public class LambdaExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        // 使用 Lambda 表达式和 Stream API 过滤偶数
        List<Integer> evenNumbers = numbers.stream()
                .filter(n -> n % 2 == 0)
                .collect(Collectors.toList());

        System.out.println("Even numbers: " + evenNumbers);  // 输出：Even numbers: [2, 4, 6, 8]
    }
}

3.3 使用 `Comparator` 和 Lambda 表达式排序

Lambda 表达式可以简化排序操作，特别是与 Comparator 接口一起使用时。

import java.util.*;

public class LambdaExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Banana", "Apple", "Cherry", "Mango");

        // 使用 Lambda 表达式排序
        list.sort((s1, s2) -> s1.compareTo(s2));

        System.out.println("Sorted list: " + list);  // 输出：Sorted list: [Apple, Banana, Cherry, Mango]
    }
}

4. 函数式接口

Java 8 引入了函数式接口的概念，函数式接口是只包含一个抽象方法的接口，可以被 Lambda 表达式实现。

4.1 自定义函数式接口

@FunctionalInterface
interface Greeting {
    void sayHello(String name);
}

public class LambdaExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现函数式接口
        Greeting greeting = name -> System.out.println("Hello, " + name);
        greeting.sayHello("Alice");  // 输出：Hello, Alice
    }
}

4.2 常见的内置函数式接口

Java 8 提供了一些常用的函数式接口，例如：

Runnable：没有参数，返回值为 void。
Supplier<T>：没有参数，返回类型为 T。
Consumer<T>：接受一个参数，返回类型为 void。
Function<T, R>：接受一个参数 T，返回类型为 R。
Predicate<T>：接受一个参数 T，返回 boolean 值。

5. 方法引用

方法引用是 Lambda 表达式的简化形式，允许通过方法的名字来引用方法。方法引用可以使代码更加简洁。

5.1 静态方法引用

public class MethodReferenceExample {
    public static void main(String[] args) {
        // 使用方法引用替代 Lambda 表达式
        Greeting greeting = MethodReferenceExample::sayHello;
        greeting.sayHello("Alice");  // 输出：Hello, Alice
    }

    public static void sayHello(String name) {
        System.out.println("Hello, " + name);
    }
}

5.2 实例方法引用

public class MethodReferenceExample {
    public static void main(String[] args) {
        MethodReferenceExample example = new MethodReferenceExample();
        // 使用实例方法引用
        Greeting greeting = example::greet;
        greeting.sayHello("Bob");  // 输出：Hello, Bob
    }

    public void greet(String name) {
        System.out.println("Hello, " + name);
    }
}

6. Java 函数式编程

Lambda 表达式是函数式编程的核心，Java 8 为我们提供了更多函数式编程的特性。

6.1 使用 `Stream` 进行函数式编程

流（Stream）是 Java 8 引入的一个新概念，它允许我们像函数式编程语言那样以声明性方式处理集合数据。

import java.util.*;
import java.util.stream.*;

public class LambdaExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

        // 使用 Stream 进行函数式编程
        int sum = numbers.stream()
                .filter(n -> n % 2 == 0)
                .mapToInt(Integer::intValue)
                .sum();

        System.out.println("Sum of even numbers: " + sum);  // 输出：Sum of even numbers: 20
    }
}