Java Lambda 表达式
Lambda 的发展史
Java Lambda 表达式是在 Java 8 版本中引入的重要特性，它描述了一种更简洁、更灵活的方式来处理函数式编程。
在 Java 8 之前，要实现函数式编程，需要通过匿名类实现接口的方式。这样的代码通常比较冗长，可读性也较差。为了改善这种情况，Java 8 引入了 Lambda 表达式。
Lambda 表达式的核心思想是：将函数作为参数传递给其他方法，或者将函数作为结果返回。通过 Lambda 表达式，我们可以使用更紧凑和清晰的语法来定义匿名函数。
以下是 Java Lambda 在发展史上的一些主要里程碑：
-
Java 8： Java 8 中首次引入了 Lambda 表达式。Lambda 表达式由箭头符号
->分隔为两部分，左侧是参数列表，右侧是表达式或代码块。Lambda 表达式可以简化集合的遍历、线程的创建等常见编程任务。 -
Java 8： Java 8 还引入了函数式接口（Functional Interface），它是一个只有一个抽象方法的接口。函数式接口可以用作 Lambda 表达式的类型。
-
Java 8： 引入了一些新的函数式接口，如
Predicate、Consumer、Supplier和Function。它们提供了常见的函数式操作，如过滤、映射、遍历等。 -
Java 8： 引入了方法引用（Method Reference），它允许直接引用现有的方法作为 Lambda 表达式，进一步简化代码。
-
Java 9： Java 9 对 Lambda 表达式进行了一些改进，引入了
Stream接口的新方法，如takeWhile和dropWhile，以及一些新的函数式接口，如Optional类的ifPresentOrElse方法。 -
Java 11： Java 11 对 Lambda 表达式进行了一些增强，允许在 Lambda 表达式的参数列表中使用
var关键字来推断参数的类型。
Lambda 表达式的引入使得 Java 语言更接近函数式编程的风格，使代码更加简洁、易读和易维护。它是 Java 语言发展中的重要里程碑之一，并为后续版本中的其他功能和框架提供了基础。
一，Lambda 表达式的使用
Lambda 表达式是 Java 8 引入的一个重要特性，它允许我们以更简洁的方式编写匿名函数。Lambda 表达式在函数式接口（Functional Interface）中使用，函数式接口是指只包含一个抽象方法的接口。
Lambda 表达式的一般语法如下：
(parameters) -> expression/statement
其中，(parameters) 是参数列表；-> 是 Lambda 运算符；expression/statement 是 Lambda 表达式的实现体，可以是单个表达式或多个语句块。
以下是使用 Lambda 表达式的示例代码：
- 使用 Lambda 表达式实现 Runnable 接口：
Runnable runnable = () -> {
System.out.println("Running in a separate thread.");
};
new Thread(runnable).start();
- 使用 Lambda 表达式实现 Comparator 接口：
List<String> names = Arrays.asList("John", "Mary", "Alice", "Bob");
Collections.sort(names, (name1, name2) -> name1.compareTo(name2));
for (String name : names) {
System.out.println(name);
}
- 使用 Lambda 表达式遍历集合：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.forEach(number -> System.out.println(number));
- 使用 Lambda 表达式进行条件判断：
Predicate<Integer> isEven = num -> num % 2 == 0;
System.out.println(isEven.test(4)); // 输出：true
System.out.println(isEven.test(3)); // 输出：false
Lambda 表达式能够使代码更加简洁、易读，并且可以方便地在函数式接口中使用。它广泛应用于集合操作、多线程编程以及函数式编程等场景中。正因为如此，掌握 Lambda 表达式的使用对于 Java 开发者来说是非常重要的。
二，Lambda 表达式stream API的结合
Java Lambda 表达式和 Stream API 的结合可以提供一种强大的编程模型，用于对集合数据进行处理和操作。
Stream 是 Java 8 引入的一个新的抽象概念，它代表了对数据元素序列进行连续操作的功能。Stream API 提供了丰富的操作方法，可以使我们以更简洁、流畅的方式对集合进行过滤、映射、排序、聚合等操作。
下面是一些使用 Lambda 表达式和 Stream API 结合的示例：
- 过滤操作：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
.filter(number -> number % 2 == 0)
.collect(Collectors.toList());
System.out.println(evenNumbers); // 输出：[2, 4]
- 映射操作：
List<String> names = Arrays.asList("John", "Mary", "Alice");
List<Integer> nameLengths = names.stream()
.map(name -> name.length())
.collect(Collectors.toList());
System.out.println(nameLengths); // 输出：[4, 4, 5]
- 排序操作：
List<String> names = Arrays.asList("John", "Mary", "Alice");
List<String> sortedNames = names.stream()
.sorted((name1, name2) -> name1.compareTo(name2))
.collect(Collectors.toList());
System.out.println(sortedNames); // 输出：[Alice, John, Mary]
- 聚合操作：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
.reduce(0, (num1, num2) -> num1 + num2);
System.out.println(sum); // 输出：15
以上示例展示了 Lambda 表达式和 Stream API 的结合使用。通过使用 Lambda 表达式，我们可以以更简洁的方式定义操作的逻辑；而 Stream API 则提供了丰富的中间操作和终端操作方法，使得我们能够以流畅的方式对集合数据进行处理和操作。这种结合能够大大提高我们的开发效率，并且代码更加具有可读性和可维护性。
三，Lambda 整合集合+常规操作
List
Java Lambda 表达式可以与List集合和常规操作进行整合，以提供一种更简洁、更可读的代码编写方式。以下是几个示例：
- 集合遍历操作：
List<String> names = Arrays.asList("John", "Mary", "Alice");
// 使用 foreach 循环遍历
names.forEach(name -> System.out.println(name));
// 使用 Stream API 进行遍历
names.stream().forEach(name -> System.out.println(name));
- 常规操作：
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// 使用 reduce 方法求和
int sum = numbers.stream()
.reduce(0, (num1, num2) -> num1 + num2);
System.out.println(sum);
// 使用 filter 方法过滤元素
List<Integer> evenNumbers = numbers.stream()
.filter(number -> number % 2 == 0)
.collect(Collectors.toList());
System.out.println(evenNumbers);
// 使用 map 方法对元素进行映射操作
List<String> names = numbers.stream()
.map(number -> "Name" + number)
.collect(Collectors.toList());
System.out.println(names);
Map
Lambda 表达式允许程序员在不需要编写冗长代码的情况下进行更复杂的操作。而与集合和常规操作相结合，使用 Lambda 表达式可以使代码更加简洁、可维护和易读，并且可以提高生产力。
使用 Lambda 表达式和 Map 集合结合，可以实现对集合中元素的映射、过滤、聚合等常规操作。以下是几个示例：
- 遍历 Map 集合：
Map<String, Integer> scores = new HashMap<>();
scores.put("John", 90);
scores.put("Mary", 80);
scores.put("Alice", 85);
// 遍历 Map 的键值对
scores.forEach((name, score) -> System.out.println(name + " : " + score));
// 遍历 Map 的键
scores.keySet().forEach(key -> System.out.println(key));
// 遍历 Map 的值
scores.values().forEach(value -> System.out.println(value));
- 过滤操作：
Map<String, Integer> scores = new HashMap<>();
scores.put("John", 90);
scores.put("Mary", 80);
scores.put("Alice", 85);
// 过滤出分数大于 85 的元素
Map<String, Integer> filteredScores = scores.entrySet()
.stream()
.filter(entry -> entry.getValue() > 85)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
System.out.println(filteredScores);
- 映射操作：
Map<String, Integer> scores = new HashMap<>();
scores.put("John", 90);
scores.put("Mary", 80);
scores.put("Alice", 85);
// 将每个分数增加 5 分
Map<String, Integer> updatedScores = scores.entrySet()
.stream()
.map(entry -> {
entry.setValue(entry.getValue() + 5);
return entry;
})
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
System.out.println(updatedScores);
- 聚合操作：
Map<String, Integer> scores = new HashMap<>();
scores.put("John", 90);
scores.put("Mary", 80);
scores.put("Alice", 85);
// 计算所有分数的平均值
double averageScore = scores.values()
.stream()
.mapToInt(Integer::intValue)
.average()
.orElse(0);
System.out.println(averageScore);
通过使用 Lambda 表达式与 Map 集合相结合，可以以更简洁、流畅的方式对集合中的元素进行操作。我们可以使用 forEach 方法遍历 Map 的键值对或键/值；使用 filter 方法过滤出符合条件的元素；使用 map 方法对元素进行映射操作；使用 reduce 或聚合方法对元素进行汇总等操作。这种结合可以帮助我们更高效地处理 Map 集合中的数据。
Set
使用 Lambda 表达式和 Set 集合结合，可以实现对集合中元素的映射、过滤、聚合等常规操作。以下是几个示例：
- 遍历 Set 集合：
Set<String> names = new HashSet<>();
names.add("John");
names.add("Mary");
names.add("Alice");
// 使用 forEach 遍历 Set
names.forEach(name -> System.out.println(name));
// 使用 Stream API 进行遍历
names.stream().forEach(name -> System.out.println(name));
- 过滤操作：
Set<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
// 过滤出偶数元素
Set<Integer> evenNumbers = numbers.stream()
.filter(number -> number % 2 == 0)
.collect(Collectors.toSet());
System.out.println(evenNumbers);
- 映射操作：
Set<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
// 将每个元素乘以 2
Set<Integer> mappedNumbers = numbers.stream()
.map(number -> number * 2)
.collect(Collectors.toSet());
System.out.println(mappedNumbers);
- 聚合操作：
Set<Integer> numbers = new HashSet<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
// 计算所有元素的和
int sum = numbers.stream().reduce(0, (num1, num2) -> num1 + num2);
System.out.println(sum);
通过使用 Lambda 表达式与 Set 集合相结合，可以以更简洁、流畅的方式对集合中的元素进行操作。我们可以使用 forEach 方法遍历 Set；使用 filter 方法过滤出符合条件的元素；使用 map 方法对元素进行映射操作；使用 reduce 或聚合方法对元素进行汇总等操作。这种结合可以帮助我们更高效地处理 Set 集合中的数据。
Lambda 表达式的局限性
尽管 Lambda 表达式提供了一种简洁、灵活的编程方式，但也存在一些局限性。以下是 Lambda 表达式的一些局限性：
-
必须满足函数接口要求：Lambda 表达式必须与函数接口（只有一个抽象方法的接口）相匹配。这意味着 Lambda 表达式不能用于任意的方法或任意的接口。
-
缺乏可读性：过于复杂的 Lambda 表达式可能降低代码的可读性。当 Lambda 表达式变得很长或包含复杂逻辑时，可读性可能会受到影响。
-
无法使用非 final 变量：在 Lambda 表达式中使用的局部变量必须是 final 或 effectively final（在变量声明后不再修改）。这是因为 Lambda 表达式捕获变量时实际上是创建了一个新的变量副本，并且这个副本必须保持不可变。
-
不支持跳出多层嵌套循环：Lambda 表达式内部无法使用 break 或 continue 关键字跳出多层嵌套循环。它只能在当前循环内部进行断言。
-
难以调试：相对于传统的方法和类，Lambda 表达式的调试可能会更加困难。由于 Lambda 表达式是匿名函数，调试时可能难以追踪和定位问题。
-
可能引发性能问题：虽然 Lambda 表达式提供了便利的语法，但在某些情况下可能导致性能问题。Lambda 表达式会引入额外的开销，尤其是在需要进行大量迭代或频繁调用时。
尽管存在这些局限性，Lambda 表达式仍然是 Java 8 引入的重要特性，可以帮助我们编写更简洁、易读的代码，并促进函数式编程思想的应用。对于大多数常规的编程任务，Lambda 表达式仍然是一种强大而实用的工具。
