# 开发趋势 Java Lambda 表达式 第三篇

开发趋势 Java Lambda 表达式 第三篇

一，Lambda 整合集合+常规操作

List

Java Lambda 表达式可以与List集合和常规操作进行整合，以提供一种更简洁、更可读的代码编写方式。以下是几个示例：

1. 集合遍历操作：

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));
1
2
3
4
5
6
7

2. 常规操作：

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Map

Lambda 表达式允许程序员在不需要编写冗长代码的情况下进行更复杂的操作。而与集合和常规操作相结合，使用 Lambda 表达式可以使代码更加简洁、可维护和易读，并且可以提高生产力。

使用 Lambda 表达式和 Map 集合结合，可以实现对集合中元素的映射、过滤、聚合等常规操作。以下是几个示例：

1. 遍历 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));
1
2
3
4
5
6
7
8
9
10
11
12
13

2. 过滤操作：

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);
1
2
3
4
5
6
7
8
9
10
11
12

3. 映射操作：

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);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4. 聚合操作：

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);
1
2
3
4
5
6
7
8
9
10
11
12
13

通过使用 Lambda 表达式与 Map 集合相结合，可以以更简洁、流畅的方式对集合中的元素进行操作。我们可以使用 forEach 方法遍历 Map 的键值对或键/值；使用 filter 方法过滤出符合条件的元素；使用 map 方法对元素进行映射操作；使用 reduce 或聚合方法对元素进行汇总等操作。这种结合可以帮助我们更高效地处理 Map 集合中的数据。

Set

使用 Lambda 表达式和 Set 集合结合，可以实现对集合中元素的映射、过滤、聚合等常规操作。以下是几个示例：

1. 遍历 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));
1
2
3
4
5
6
7
8
9
10

2. 过滤操作：

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);
1
2
3
4
5
6
7
8
9
10
11
12

3. 映射操作：

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);
1
2
3
4
5
6
7
8
9
10
11

4. 聚合操作：

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);
1
2
3
4
5
6
7
8
9
10

通过使用 Lambda 表达式与 Set 集合相结合，可以以更简洁、流畅的方式对集合中的元素进行操作。我们可以使用 forEach 方法遍历 Set；使用 filter 方法过滤出符合条件的元素；使用 map 方法对元素进行映射操作；使用 reduce 或聚合方法对元素进行汇总等操作。这种结合可以帮助我们更高效地处理 Set 集合中的数据。

Lambda 表达式的局限性

尽管 Lambda 表达式提供了一种简洁、灵活的编程方式，但也存在一些局限性。以下是 Lambda 表达式的一些局限性：

1. 必须满足函数接口要求：Lambda 表达式必须与函数接口（只有一个抽象方法的接口）相匹配。这意味着 Lambda 表达式不能用于任意的方法或任意的接口。

2. 缺乏可读性：过于复杂的 Lambda 表达式可能降低代码的可读性。当 Lambda 表达式变得很长或包含复杂逻辑时，可读性可能会受到影响。

3. 无法使用非 final 变量：在 Lambda 表达式中使用的局部变量必须是 final 或 effectively final（在变量声明后不再修改）。这是因为 Lambda 表达式捕获变量时实际上是创建了一个新的变量副本，并且这个副本必须保持不可变。

4. 不支持跳出多层嵌套循环：Lambda 表达式内部无法使用 break 或 continue 关键字跳出多层嵌套循环。它只能在当前循环内部进行断言。

5. 难以调试：相对于传统的方法和类，Lambda 表达式的调试可能会更加困难。由于 Lambda 表达式是匿名函数，调试时可能难以追踪和定位问题。

6. 可能引发性能问题：虽然 Lambda 表达式提供了便利的语法，但在某些情况下可能导致性能问题。Lambda 表达式会引入额外的开销，尤其是在需要进行大量迭代或频繁调用时。

尽管存在这些局限性，Lambda 表达式仍然是 Java 8 引入的重要特性，可以帮助我们编写更简洁、易读的代码，并促进函数式编程思想的应用。对于大多数常规的编程任务，Lambda 表达式仍然是一种强大而实用的工具。