java Lambda表达式与函数式接口

Java Lambda表达式和函数式接口是Java 8引入的重要特性，它们极大地简化了函数式编程风格的使用，使得代码更加简洁、可读性强。下面详细介绍Lambda表达式和函数式接口的概念、用法及示例。

Lambda表达式的概念

Lambda表达式是一种匿名函数，它可以像普通函数一样传递参数和返回值，但不需要显式定义函数名称。Lambda表达式通常用于实现单个抽象方法的接口，即所谓的“函数式接口”。

语法

Lambda表达式的语法格式如下：

(parameters) -> expression | statement

• parameters：参数列表。
• ->：箭头符号，表示lambda头和lambda体之间的分隔符。
• expression | statement：表达式或语句块。

示例

// 无参数，无返回值
() -> System.out.println("Hello, World!");

// 一个参数，无返回值
(x) -> System.out.println(x);

// 两个参数，返回值
(int x, int y) -> x + y;

// 参数类型可以省略
(x, y) -> x + y;

// 语句块形式
(int x, int y) -> {
    int sum = x + y;
    return sum;
}

函数式接口

函数式接口（Functional Interface）是一个只有一个抽象方法的接口。在Java中，可以通过@FunctionalInterface注解来明确声明一个接口是函数式接口。虽然不是必须使用该注解，但它有助于编译器检查接口是否符合函数式接口的要求。

示例

@FunctionalInterface
public interface MyFunction {
    int apply(int x, int y);
}

常见的函数式接口

Java标准库中提供了许多常用的函数式接口，这些接口可以方便地用于Lambda表达式的定义和使用。

1. java.util.function包中的接口

• FunctionalInterface：注解，用于标记函数式接口。
• Predicate<T>：接收一个参数，返回一个布尔值。
• Consumer<T>：接收一个参数，没有返回值。
• Supplier<T>：没有参数，返回一个值。
• Function<T, R>：接收一个参数，返回另一个类型的值。
• UnaryOperator<T>：接收一个参数，返回相同类型的值。
• BinaryOperator<T>：接收两个相同类型的参数，返回相同类型的值。
• IntFunction<R>：接收一个int参数，返回另一个类型的值。
• IntPredicate：接收一个int参数，返回一个布尔值。
• IntConsumer：接收一个int参数，没有返回值。
• IntSupplier：没有参数，返回一个int值。
• IntUnaryOperator：接收一个int参数，返回一个int值。
• IntBinaryOperator：接收两个int参数，返回一个int值。

示例

import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

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

        // Consumer<T>
        Consumer<String> printUpperCase = s -> System.out.println(s.toUpperCase());
        printUpperCase.accept("hello"); // 输出 HELLO

        // Function<T, R>
        Function<Integer, Integer> square = x -> x * x;
        System.out.println(square.apply(5)); // 输出 25

        // Supplier<T>
        Supplier<String> getGreeting = () -> "Hello, World!";
        System.out.println(getGreeting.get()); // 输出 Hello, World!

        // UnaryOperator<T>
        UnaryOperator<Integer> increment = x -> x + 1;
        System.out.println(increment.apply(5)); // 输出 6

        // BinaryOperator<T>
        BinaryOperator<Integer> add = Integer::sum;
        System.out.println(add.apply(3, 4)); // 输出 7

        // IntFunction<R>
        IntFunction<String> repeat = times -> "a".repeat(times);
        System.out.println(repeat.apply(3)); // 输出 aaa

        // IntPredicate
        IntPredicate isPositive = x -> x > 0;
        System.out.println(isPositive.test(5)); // 输出 true

        // IntConsumer
        IntConsumer print = System.out::println;
        print.accept(42); // 输出 42

        // IntSupplier
        IntSupplier getNumber = () -> 42;
        System.out.println(getNumber.getAsInt()); // 输出 42

        // IntUnaryOperator
        IntUnaryOperator negate = x -> -x;
        System.out.println(negate.applyAsInt(5)); // 输出 -5

        // IntBinaryOperator
        IntBinaryOperator multiply = (x, y) -> x * y;
        System.out.println(multiply.applyAsInt(3, 4)); // 输出 12
    }
}

Lambda表达式的使用场景

Lambda表达式常用于以下场景：

1. 集合操作：

   • List的forEach方法。
   • Stream API的各种操作，如filter、map、reduce等。

2. 事件处理：

   • GUI编程中的事件监听器。

3. 函数式编程：

   • 高阶函数和函数组合。

示例：集合操作

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

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

        // 使用Lambda表达式遍历集合
        numbers.forEach(System.out::println);

        // 使用Lambda表达式过滤集合
        List<Integer> evenNumbers = numbers.stream()
                .filter(x -> x % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(evenNumbers); // 输出 [2, 4]
    }
}

总结

Java Lambda表达式和函数式接口是Java 8引入的重要特性，它们极大地简化了函数式编程风格的使用。Lambda表达式允许我们以简洁的方式定义匿名函数，而函数式接口则提供了一个标准的方式来定义单个抽象方法的接口。

通过使用Lambda表达式和函数式接口，可以实现更加简洁、灵活和可读性强的代码。Java标准库中提供了许多常用的函数式接口，如Predicate、Consumer、Function等，可以方便地用于Lambda表达式的定义和使用。

掌握Lambda表达式和函数式接口的基本概念和用法后，可以更好地利用这些特性来编写高效、简洁的Java应用程序。