## Java中的Lambda表达式
### 1. 简介
Lambda表达式是Java 8引入的一项重要新特性，它是Java对函数式编程支持的一部分。Lambda表达式允许将匿名函数作为参数传递，简化了代码，提升了可读性和可维护性。Lambda表达式的主要目的是使代码更加简洁、灵活，尤其在处理集合、并发编程以及GUI编程中。
### 2. Lambda表达式的基本语法
Lambda表达式的基本语法形式如下：
```
(parameters) -> expression
或
(parameters) -> { statements }
```
#### 2.1 参数列表
参数列表可以为空，也可以包含一个或多个参数。多个参数之间用逗号分隔。
- 如果只有一个参数且无类型，可以省略圆括号。例如：`x -> x * x`
- 如果参数有类型，必须包括在圆括号内。例如：`(int x, int y) -> x + y`
#### 2.2 箭头符号
箭头符号 `->` 用于将参数列表与表达式或代码块分开。
#### 2.3 方法体
方法体可以是一个单一的表达式，也可以是一个包含多条语句的代码块。如果是单一表达式，结果会自动返回。如果是代码块，必须显式使用 `return` 语句返回结果。
### 3. Lambda表达式的使用示例
下面是一些使用Lambda表达式的基本示例：
#### 3.1 无参数的Lambda表达式
```java
Runnable r1 = () -> System.out.println("Hello, World!");
r1.run();
```
#### 3.2 一个参数的Lambda表达式
```java
UnaryOperator<Integer> square = x -> x * x;
System.out.println(square.apply(5)); // 输出: 25
```
#### 3.3 多个参数的Lambda表达式
```java
BinaryOperator<Integer> add = (a, b) -> a + b;
System.out.println(add.apply(3, 5)); // 输出: 8
```
### 4. 函数式接口
Lambda表达式可以替代匿名类，尤其是在实现函数式接口时。函数式接口是只包含一个抽象方法的接口，可以包含多个默认方法和静态方法。
#### 4.1 函数式接口示例
```java
@FunctionalInterface
interface MyFunctionalInterface {
void execute();
}
```
#### 4.2 使用Lambda表达式实现函数式接口
```java
MyFunctionalInterface myFunc = () -> System.out.println("Executing...");
myFunc.execute();
```
Java 8中的许多新特性都是基于函数式接口实现的，如`java.util.function`包中的接口。
### 5. 常用的函数式接口
Java 8引入了一些常用的函数式接口，这些接口都在`java.util.function`包中定义。
#### 5.1 `Predicate<T>`
`Predicate` 接口用于对输入参数进行判断，返回一个布尔值。
```java
Predicate<Integer> isEven = x -> x % 2 == 0;
System.out.println(isEven.test(4)); // 输出: true
```
#### 5.2 `Function<T, R>`
`Function` 接口用于将输入参数转换为另一种类型的结果。
```java
Function<String, Integer> stringLength = s -> s.length();
System.out.println(stringLength.apply("Lambda")); // 输出: 6
```
#### 5.3 `Consumer<T>`
`Consumer` 接口用于对输入参数进行操作但不返回结果。
```java
Consumer<String> print = s -> System.out.println(s);
print.accept("Hello, Lambda!"); // 输出: Hello, Lambda!
```
#### 5.4 `Supplier<T>`
`Supplier` 接口用于提供一个结果，不需要输入参数。
```java
Supplier<Double> random = () -> Math.random();
System.out.println(random.get());
```
#### 5.5 `BinaryOperator<T>`
`BinaryOperator` 接口用于对两个相同类型的参数进行操作，并返回与参数类型相同的结果。
```java
BinaryOperator<Integer> multiply = (a, b) -> a * b;
System.out.println(multiply.apply(3, 4)); // 输出: 12
```
### 6. Lambda表达式在集合框架中的应用
Lambda表达式与Java集合框架结合使用，可以极大地简化代码。
#### 6.1 使用Lambda表达式进行集合遍历
```java
List<String> list = Arrays.asList("a", "b", "c");
list.forEach(s -> System.out.println(s));
```
#### 6.2 使用Lambda表达式进行集合过滤
```java
List<String> strings = Arrays.asList("abc", "", "bc", "efg", "abcd", "", "jkl");
List<String> filtered = strings.stream()
.filter(s -> !s.isEmpty())
.collect(Collectors.toList());
System.out.println(filtered);
```
#### 6.3 使用Lambda表达式进行集合映射
```java
List<Integer> numbers = Arrays.asList(3, 2, 2, 3, 7, 3, 5);
List<Integer> squaresList = numbers.stream()
.map(i -> i * i)
.distinct()
.collect(Collectors.toList());
System.out.println(squaresList);
```
### 7. 方法引用
方法引用是Lambda表达式的另一种简洁形式。它使用现有的方法定义作为Lambda表达式的一部分。
#### 7.1 静态方法引用
```java
Function<String, Integer> parseInt = Integer::parseInt;
System.out.println(parseInt.apply("123")); // 输出: 123
```
#### 7.2 实例方法引用
```java
String str = "Hello";
Supplier<Integer> strLength = str::length;
System.out.println(strLength.get()); // 输出: 5
```
#### 7.3 特定对象的实例方法引用
```java
Function<String, Integer> stringLength = String::length;
System.out.println(stringLength.apply("Lambda")); // 输出: 6
```
#### 7.4 构造器引用
```java
Supplier<ArrayList<String>> newList = ArrayList::new;
ArrayList<String> list = newList.get();
System.out.println(list);
```
### 8. Lambda表达式与并行流
Lambda表达式与并行流结合使用，可以利用多核处理器的并行计算能力，提高程序性能。
```java
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int sum = numbers.parallelStream()
.filter(x -> x % 2 == 0)
.mapToInt(Integer::intValue)
.sum();
System.out.println("Sum of even numbers: " + sum);
```
### 9. Lambda表达式的优缺点
#### 9.1 优点
1. **简洁性**：Lambda表达式使代码更简洁，减少了样板代码。
2. **可读性**：代码更易于阅读和理解。
3. **函数式编程**：支持函数式编程范式，使代码更灵活。
4. **并行处理**：与流API结合使用，能够轻松实现并行计算，提高性能。
#### 9.2 缺点
1. **调试困难**：Lambda表达式中的错误信息可能不如传统代码中的清晰，调试起来可能更困难。
2. **性能开销**：在某些情况下，Lambda表达式可能会引入性能开销，尤其是在频繁创建短生命周期对象时。
3. **学习曲线**：对于不熟悉函数式编程的开发者，可能需要一些时间来学习和掌握Lambda表达式的使用。
### 10. Lambda表达式的注意事项
1. **类型推断**：Lambda表达式依赖于类型推断，编译器会根据上下文推断参数类型。
2. **接口的抽象方法**：Lambda表达式只能用于具有一个抽象方法的接口（函数式接口）。
3. **变量作用域**：Lambda表达式中的局部变量必须是隐式最终（即不能在Lambda表达式外部修改）。
4. **调试与日志**：在Lambda表达式中加入调试和日志代码时，应注意代码的简洁性和可读性。
### 11. 总结
Lambda表达式是Java 8引入的一个重要特性，旨在简化代码，提高可读性和可维护性。通过支持函数式编程，Lambda表达式使Java变得更加灵活和现代化。本文详细介绍了Lambda表达式的基本语法、函数式接口、常用函数式接口、集合框架中的应用、方法引用、并行流以及Lambda表达式的优缺点和注意事项。
通过深入理解和掌握Lambda表达式，开发者可以编写出更简洁、高效和易维护的代码。在实际开发中，合理使用Lambda表达式和流API，可以显著提升代码的质量和性能。
