Java Lambda 表达式详解

Java Lambda 表达式是一种匿名函数，也称为闭包。它可以作为参数传递到方法中或者在集合框架中进行迭代。Lambda 表达式可以显著地简化代码，并提高代码的可读性和可维护性。

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

(parameter1, parameter2, …, parameterN) -> {
// Lambda body
}

其中，parameter1、parameter2 等是 Lambda 表达式的形式参数，箭头符号 “->” 分隔了参数和 Lambda body（Lambda 主体）。

Lambda body 可以是一个表达式，也可以是一组语句块。如果 Lambda body 是一个表达式，那么它的值将自动返回。如果 Lambda body 是一组语句块，则必须使用花括号将其括起来，并且需要显式地返回值。

以下是一些常用的与 Lambda 表达式相关的 API 的使用案例：

1. java.util.function 包

Predicate 接口：该接口提供了一个抽象方法 test()，可以接受一个参数并返回一个布尔值。Lambda 表达式常用于实现 Predicate 接口，例如：

List<String> list = Arrays.asList("Java", "Python", "JavaScript");
list.removeIf(str -> str.startsWith("Java")); // 使用 Lambda 表达式实现 Predicate
System.out.println(list);

Consumer 接口：该接口提供了一个抽象方法 accept()，可以接受一个参数并进行消费（没有返回值）。Lambda 表达式常用于实现 Consumer 接口，例如：

List<String> list = Arrays.asList("Java", "Python", "JavaScript");
list.forEach(str -> System.out.println(str)); // 使用 Lambda 表达式实现 Consumer

Function<T, R> 接口：该接口提供了一个抽象方法 apply()，可以接受一个参数并返回一个结果。Lambda 表达式常用于实现 Function 接口，例如：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = list.stream().map(str -> str.length()).collect(Collectors.toList()); // 使用 Lambda 表达式实现 Function
System.out.println(lengths);

2. java.util.stream.Stream 类

filter() 方法：该方法可以接收一个 Predicate 类型的 Lambda 表达式作为参数，用于过滤集合中的元素。例如：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream().filter(str -> str.startsWith("a")).collect(Collectors.toList()); // 使用 Lambda 表达式实现 Predicate
System.out.println(filteredList);

map() 方法：该方法可以接收一个 Function 类型的 Lambda 表达式作为参数，用于对集合中的元素进行映射。例如：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = list.stream().map(str -> str.length()).collect(Collectors.toList()); // 使用 Lambda 表达式实现 Function
System.out.println(lengths);

sorted() 方法：该方法可以接收一个 Comparator 类型的 Lambda 表达式作为参数，用于对集合进行排序。例如：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> sortedList = list.stream().sorted((str1, str2) -> str1.compareTo(str2)).collect(Collectors.toList()); // 使用 Lambda 表达式实现 Comparator
System.out.println(sortedList);

3. java.util.Comparator 接口

该接口定义了比较器相关的方法，例如 compare()、reversed() 等。可以使用 Lambda 表达式实现自己的比较器。例如：

List<String> list = Arrays.asList("apple", "banana", "orange");
Comparator<String> myComparator = (str1, str2) -> str1.length() - str2.length(); // 使用 Lambda 表达式实现 Comparator
Collections.sort(list, myComparator);
System.out.println(list);

4. java.util.concurrent.CompletableFuture 类

thenApply() 方法：该方法可以接收一个 Function 类型的 Lambda 表达式作为回调函数，用于处理计算结果。例如：

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 42);
future.thenApply(result -> result * 2).thenAccept(System.out::println); // 使用 Lambda 表达式实现 Function

5. java.lang.Runnable 接口

该接口只有一个无参的 run() 方法，常用于创建线程。可以使用 Lambda 表达式实现 Runnable 接口。例如：

Runnable runnable = () -> System.out.println("Hello, world!"); // 使用 Lambda 表达式实现 Runnable
new Thread(runnable).start();

6. java.util.concurrent.Callable 接口

该接口只有一个 call() 方法，可以返回一个结果，并可能会抛出异常。也可以使用 Lambda 表达式实现 Callable 接口。例如：

Callable<Integer> callable = () -> {
    TimeUnit.SECONDS.sleep(1);
    return 42;
}; // 使用 Lambda 表达式实现 Callable
ExecutorService executor = Executors.newCachedThreadPool();
Future<Integer> future = executor.submit(callable);
Integer result = future.get();
System.out.println(result);
executor.shutdown();

在上面的示例中，使用 Lambda 表达式实现了一个 Callable 对象，并将其提交给 ExecutorService 执行器来异步执行。然后通过 Future 接口的 get() 方法获取计算结果，并关闭执行器。

如何自定义Lambda 式编程，下面是一个使用Lambda表达式定义函数接口的示例：

在Java 8中，Lambda表达式通常用于创建函数接口（Functional Interface）。函数接口是只包含一个抽象方法的接口。我们可以使用Lambda表达式来实现这个接口的抽象方法，从而避免编写冗长的类和匿名内部类。

例如，我们定义一个简单的函数接口来计算两个整数的和：

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

在上面的代码中，我们使用了@FunctionalInterface注解来标记这是一个函数接口，并且它只包含一个抽象方法calculate。

然后，我们可以使用Lambda表达式来实现这个接口的抽象方法，如下所示：

Calculator add = (a, b) -> a + b;
int result = add.calculate(10, 5);
System.out.println("10 + 5 = " + result); // 输出：10 + 5 = 15

在上面的代码中，我们创建了一个名为add的Calculator类型的变量，并用一个Lambda表达式 (a, b) -> a + b 来实现calculate方法。这个Lambda表达式接受两个参数a和b，并返回它们的和。

最后，我们调用add.calculate(10, 5)方法来计算10和5的和，并将结果打印到控制台上。

Lambda 表达式不仅可以简化代码，还可以提高代码的可读性和可维护性。但是需要注意，Lambda 表达式虽然方便，但并不总是比普通函数更好，有时候可能甚至会影响代码的性能。因此，在编写代码时应该根据具体情况选择合适的方法。