Lambda的背景
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression），基于数学中的λ演算得名，也可称为闭包（Closure） 。
Lambda表达式的语法
基本语法:
(parameters) -> expression 或 (parameters) ->{ statements; }
Lambda表达式由三部分组成：
- 1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明
- 也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
- 2. ->：可理解为“被用于”的意思
- 3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。
// 1. 不需要参数,返回值为 2
() -> 2
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)
函数式接口
在介绍Lambda表达式的使用的时候我们先来介绍函数式接口，这有助于我们快速了解Lambda表达式。
在Java中，函数式接口是指仅包含一个抽象方法的接口，它可以被隐式转换为一个 lambda 表达式或者方法引用。函数式接口的主要用途是支持函数式编程，使得代码更加简洁和易于阅读。
特点：
- 单一抽象方法：函数式接口只能有一个未实现的方法，这使得它可以表示单一的行为。
- 默认方法：虽然只能有一个抽象方法，但函数式接口可以包含多个默认方法和静态方法。
- @FunctionalInterface 注解：使用
@FunctionalInterface注解可以清晰地表明一个接口是函数式接口，编译器会强制检查是否满足函数式接口的条件。
示例：
@FunctionalInterface
public interface MyFunctionalInterface {
void execute();
default void defaultMethod() {
System.out.println("This is a default method.");
}
static void staticMethod() {
System.out.println("This is a static method.");
}
}
可以使用 lambda 表达式来实现这个函数式接口：
public class Main {
public static void main(String[] args) {
MyFunctionalInterface myFunc = () -> System.out.println("Executing...");
myFunc.execute(); // 输出: Executing...
myFunc.defaultMethod(); // 输出: This is a default method.
MyFunctionalInterface.staticMethod(); // 输出: This is a static method.
}
}
结论：
函数式接口是Java 8引入的重要特性，促进了函数式编程的实现，使得编写更加简洁和灵活的代码成为可能。
Lambda表达式的使用
基本语法
Lambda表达式的基本语法如下：
(parameters) -> expression
或者如果有多个语句：
(parameters) -> { statements }
使用示例
下面的例子展示了如何在Java中使用Lambda表达式。
1. 定义函数式接口
首先，我们定义一个简单的函数式接口，该接口只有一个抽象方法：
@FunctionalInterface
public interface MyFunctionalInterface {
void apply(String message);
}
2. 使用Lambda表达式
接下来，我们使用Lambda表达式来实现这个接口：
public class LambdaExample {
public static void main(String[] args) {
// 使用Lambda表达式实现MyFunctionalInterface接口
MyFunctionalInterface myFunc = (message) -> System.out.println("Message: " + message);
// 调用apply方法
myFunc.apply("Hello, Lambda!"); // 输出: Message: Hello, Lambda!
}
}
另一个示例：使用Lambda表达式进行集合操作
Lambda表达式常用于集合操作，特别是与 Stream API结合时。以下是一个使用Lambda表达式过滤和打印列表中所有以“A”开头的字符串的示例：
import java.util.Arrays;
import java.util.List;
public class LambdaStreamExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Amanda", "Charlie");
// 使用Lambda表达式过滤以"A"开头的名字
names.stream()
.filter(name -> name.startsWith("A")) // 过滤以“A”开头的名字
.forEach(name -> System.out.println(name)); // 打印结果
}
}
总结
Lambda表达式通过简化代码和减少冗余，使得函数式编程在Java中变得更加容易。它特别适用于实现函数式接口，提高了代码的可读性和简洁性。通过以上示例，我们可以看到Lambda表达式在实际应用中的基本使用方式。
语法精简
- 1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
- 2. 参数的小括号里面只有一个参数，那么小括号可以省略
- 3. 如果方法体当中只有一句代码，那么大括号可以省略
- 4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。
Lambda的变量捕获
在Lambda当中也可以进行变量的捕获，具体我们看一下代码。
@FunctionalInterface
interface NoParameterNoReturn {
void test();
}
public static void main(String[] args) {
int a = 10;
NoParameterNoReturn noParameterNoReturn = ()->{
System.out.println("捕获变量："+a);
};
noParameterNoReturn.test();
}
Lambda表达式在集合中的使用
在PriorityQueue中的使用
我们在使用PriorityQueue的时候经常要传一个比较器，如下：
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});
}
}这时我们就可以用Lambda表达式来代替这个匿名内部类，如下代码：
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>((o1,o2)->{return o1 - o2;});
}
}这时就提高了代码的简洁性。
在 forEach 方法中的使用
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(3);
list.add(1);
list.add(6);
list.add(4);
list.forEach(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println(integer);
}
});
}
}这个方法的作用是遍历整个集合，在传参是的时候要使用 Consumer 这个接口，这时我们就可以利用Lambda表达式来简写代码了。如下：
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(3);
list.add(1);
list.add(6);
list.add(4);
list.forEach((a)-> System.out.println(a));
}
}
在 sort 方法中使用
sort 方法是将一个集合进行排序
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(3);
list.add(1);
list.add(6);
list.add(4);
list.forEach((a)-> System.out.println(a));
System.out.println("=====");
list.sort(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1-o2;
}
});
list.forEach((a)-> System.out.println(a));
}
}用Lambda表达式简化代码
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>();
list.add(3);
list.add(1);
list.add(6);
list.add(4);
list.forEach((a)-> System.out.println(a));
System.out.println("=====");
list.sort((o1,o2) -> {return o1 - o2;});
list.forEach((a)-> System.out.println(a));
}
}
总结
Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。
优点：
- 1. 代码简洁，开发迅速
- 2. 方便函数式编程
- 3. 非常容易进行并行计算
- 4. Java 引入 Lambda，改善了集合操作
缺点：
- 1. 代码可读性变差
- 2. 在非并行计算中，很多计算未必有传统的 for 性能要高
- 3. 不容易进行调试
