Java的Lambda表达式与函数式接口

Java的Lambda表达式与函数式接口

一、Lambda表达式

1.1 定义

Lambda表达式是Java 8引入的一个重要特性，它是一种简洁的、可传递的匿名函数。Lambda表达式可以理解为是一种没有声明的方法，即没有访问修饰符、返回值声明和名字。它允许把函数作为一个方法的参数（函数作为参数传递进方法中），或者把代码看成数据，使代码更加简洁、灵活。

1.2 语法

Lambda表达式的基本语法有两种形式：

• 无参数形式：() -> 表达式 或者 () -> { 语句块; }
  • () -> System.out.println("Hello Lambda");
  • () -> { int a = 1; System.out.println(a); }
• 有参数形式：(参数列表) -> 表达式 或者 (参数列表) -> { 语句块; }
  • (a, b) -> a + b
  • (String s) -> { System.out.println(s); }

1.3 示例

import java.util.Arrays;
import java.util.List;

public class LambdaExample {
    public static void main(String[] args) {
        // 1. 无参数的 Lambda 表达式
        Runnable runnable = () -> System.out.println("Running...");
        new Thread(runnable).start();

        // 2. 有参数的 Lambda 表达式
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        numbers.forEach(n -> System.out.print(n + " "));
    }
}

1.4 特点

• 简洁性：避免了传统匿名内部类的繁琐语法，使代码更加简洁。
• 函数式编程风格：支持将函数作为一等公民，使代码更符合函数式编程的思想。
• 延迟执行：Lambda表达式可以在需要的时候才执行，提高了程序的性能。

二、函数式接口

2.1 定义

函数式接口是指只包含一个抽象方法的接口。Java 8引入了函数式接口的概念，主要是为了支持Lambda表达式。因为Lambda表达式本质上是函数式接口的一个实例，所以只有函数式接口才能使用Lambda表达式来实现。

2.2 特点

• 单一抽象方法：函数式接口中只能有一个抽象方法，但可以有多个默认方法、静态方法和 Object 类的方法。
• 注解支持：可以使用 @FunctionalInterface 注解来标记一个接口为函数式接口。使用该注解后，编译器会检查该接口是否符合函数式接口的定义，如果不符合会报错。

2.3 示例

// 使用 @FunctionalInterface 注解标记为函数式接口
@FunctionalInterface
interface MyFunctionalInterface {
    // 唯一的抽象方法
    void doSomething();

    // 默认方法
    default void defaultMethod() {
        System.out.println("This is a default method.");
    }

    // 静态方法
    static void staticMethod() {
        System.out.println("This is a static method.");
    }
}

public class FunctionalInterfaceExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现函数式接口
        MyFunctionalInterface myFunction = () -> System.out.println("Doing something...");
        myFunction.doSomething();
        myFunction.defaultMethod();
        MyFunctionalInterface.staticMethod();
    }
}

2.4 Java内置的函数式接口

Java 8 在 java.util.function 包中提供了一系列内置的函数式接口，常见的有：

• Predicate<T>：接收一个参数，返回一个布尔值。用于判断条件是否成立。

import java.util.function.Predicate;

public class PredicateExample {
    public static void main(String[] args) {
        Predicate<Integer> isEven = num -> num % 2 == 0;
        System.out.println(isEven.test(4)); // 输出 true
    }
}

• Function<T, R>：接收一个类型为 T 的参数，返回一个类型为 R 的结果。用于进行数据转换。

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        Function<String, Integer> strLength = s -> s.length();
        System.out.println(strLength.apply("Hello")); // 输出 5
    }
}

• Consumer<T>：接收一个参数，不返回任何结果。用于消费数据。

import java.util.function.Consumer;

public class ConsumerExample {
    public static void main(String[] args) {
        Consumer<String> printUpperCase = s -> System.out.println(s.toUpperCase());
        printUpperCase.accept("hello"); // 输出 HELLO
    }
}

• Supplier<T>：不接收任何参数，返回一个类型为 T 的结果。用于提供数据。

import java.util.function.Supplier;

public class SupplierExample {
    public static void main(String[] args) {
        Supplier<Double> randomNum = () -> Math.random();
        System.out.println(randomNum.get());
    }
}

三、Lambda表达式与函数式接口的关系

Lambda表达式是函数式接口的一种简洁实现方式。当使用Lambda表达式时，实际上是在创建一个函数式接口的实例。例如：

@FunctionalInterface
interface Calculator {
    int calculate(int a, int b);
}

public class LambdaAndFunctionalInterface {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现 Calculator 接口
        Calculator adder = (a, b) -> a + b;
        System.out.println(adder.calculate(3, 5)); // 输出 8
    }
}

在上述示例中，(a, b) -> a + b 是一个Lambda表达式，它实现了 Calculator 函数式接口。通过Lambda表达式，我们可以更简洁地实现函数式接口的抽象方法。