博主 默语带您 Go to New World.
✍ 个人主页—— 默语 的博客👦🏻
《java 面试题大全》
🍩惟余辈才疏学浅，临摹之作或有不妥之处，还请读者海涵指正。☕🍭
《MYSQL从入门到精通》数据库是开发者必会基础之一~
🪁 吾期望此文有资助于尔，即使粗浅难及深广，亦备添少许微薄之助。苟未尽善尽美，敬请批评指正，以资改进。！💻⌨

理解了，我将添加更多的案例，其中将包括对比使用Lambda表达式和不使用Lambda表达式的情况，以便更全面地展示Lambda表达式的优势。让我们开始扩展这个内容吧：

1. 使用Lambda表达式进行集合遍历

1.1 未使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
for (String fruit : list) {System.out.println(fruit);
}

1.2 使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
list.forEach(fruit -> System.out.println(fruit));

Lambda表达式的使用使得集合遍历更为简洁，消除了传统for循环中的冗余代码，提升了代码的可读性和简洁性。

2. 使用Lambda表达式进行排序

2.1 未使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, new Comparator<String>() {public int compare(String s1, String s2) {return s1.compareTo(s2);}
});

2.2 使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
Collections.sort(list, (s1, s2) -> s1.compareTo(s2));

Lambda表达式的引入简化了排序操作的代码量，使得代码更加紧凑、易读。

3. 使用Lambda表达式进行过滤

3.1 未使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = new ArrayList<String>();
for (String fruit : list) {if (fruit.startsWith("a")) {filteredList.add(fruit);}
}

3.2 使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("a")).collect(Collectors.toList());

Lambda表达式简化了过滤操作，使得代码更加清晰明了，减少了中间变量的使用。

4. 使用Lambda表达式进行映射

4.1 未使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = new ArrayList<Integer>();
for (String fruit : list) {lengths.add(fruit.length());
}

4.2 使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<Integer> lengths = list.stream().map(fruit -> fruit.length()).collect(Collectors.toList());

Lambda表达式使得映射操作更加简洁明了，减少了循环代码的编写。

5. 使用Lambda表达式进行归约

5.1 未使用Lambda表达式：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = 0;
for (int i : list) {sum += i;
}

5.2 使用Lambda表达式：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
int sum = list.stream().reduce(0, (a, b) -> a + b);

Lambda表达式的引入使得归约操作更为简单，减少了冗余的循环代码，提高了代码的可读性和简洁性。

以上是对常见操作的Lambda表达式应用，接下来我们将继续探讨Lambda表达式在其他方面的应用，包括函数式接口的实现、线程创建、Optional的操作以及Stream的流水线操作。

6. 使用Lambda表达式进行分组

6.1 未使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Integer, List<String>> grouped = new HashMap<Integer, List<String>>();
for (String fruit : list) {int length = fruit.length();if (!grouped.containsKey(length)) {grouped.put(length, new ArrayList<String>());}grouped.get(length).add(fruit);
}

6.2 使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
Map<Integer, List<String>> grouped = list.stream().collect(Collectors.groupingBy(String::length));

Lambda表达式使得分组操作更加简洁，通过方法引用或Lambda表达式，能够直接传递业务逻辑，减少了样板代码的编写。

源码

package com.example.java;import java.util.*;
import java.util.stream.Collectors;public class lamdba {public static void main(String[] args) {List<String> list = Arrays.asList("apple", "orange", "banana");//todo---------------------------------------------------//1.集合遍历for (String s : list) {System.out.println("普通编码==》" + s);}list.forEach(s -> System.out.println("Lambda遍历==》" + s));//2.排序// 使用 Collections.sort() 方法对列表 list 进行排序Collections.sort(list, new Comparator<String>() {// 创建匿名内部类实现 Comparator 接口，并重写 compare 方法@Overridepublic int compare(String o1, String o2) {// 比较两个字符串 o1 和 o2 的字典顺序（升序）return o1.compareTo(o2);}});// 输出排序后的列表System.out.println("普通排序：" + list);Collections.sort(list, (s1, s2) -> s1.compareTo(s2));System.out.println("Lambda排序：" + list);//3.过滤// 创建一个新的列表 filteredList，用于存储过滤后的字符串List<String> filteredList = new ArrayList<String>();// 使用增强型 for 循环遍历原始列表 list 中的每个元素for (String s : list) {// 检查当前字符串 s 是否以字母 "a" 开头if (s.startsWith("a")) {// 如果是以 "a" 开头，则将其添加到过滤后的列表 filteredList 中filteredList.add(s);}}// 输出过滤后的列表内容System.out.println("普通过滤：" + filteredList);// 使用流式处理和 Lambda 表达式过滤原始列表 list 中以字母 "b" 开头的字符串List<String> filtered = list.stream().filter(fruit -> fruit.startsWith("b")) // 使用 filter() 方法过滤符合条件的元素.collect(Collectors.toList()); // 将过滤后的结果收集到新的列表中// 输出 Lambda 过滤后的列表内容System.out.println("Lambda过滤：" + filtered);//4.映射List<Integer> lengths = new ArrayList<Integer>();for (String s : list) {lengths.add(s.length());}System.out.println("普通映射：" + lengths);// 使用流式处理将原始列表 list 中的字符串转换为它们的长度，并收集到新的整数列表中List<Integer> length = list.stream()                // 将列表转换为一个流.map(fruit -> fruit.length())   // 使用 map() 方法将每个字符串映射为其长度.collect(Collectors.toList());  // 将映射后的长度收集到一个新的整数列表中System.out.println("Lambda映射：" + lengths);List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);//5.归约int sum = 0;for (int i : list1) {sum += i;}System.out.println("普通归约" + sum);// 使用流式处理将列表 list 中的所有元素进行求和操作int sum1 = list1.stream()                   // 将列表转换为一个流.reduce(0, (a, b) -> a + b); // 使用 reduce() 方法对流中的元素进行累加求和，初始值为 0System.out.println("Lambda归约" + sum1);//6.分组// 创建一个 HashMap，用于按字符串长度将列表 list 中的字符串分组Map<Integer, List<String>> grouped = new HashMap<Integer, List<String>>();// 遍历列表 list 中的每个字符串for (String s : list) {// 获取当前字符串 s 的长度int lengths1 = s.length();// 如果 grouped 中不包含当前长度，则添加一个新的列表if (!grouped.containsKey(lengths1)) {grouped.put(lengths1, new ArrayList<String>());}// 将当前字符串 s 加入到对应长度的列表中grouped.get(lengths1).add(s);}// 输出普通分组结果System.out.println("普通分组：" + grouped);// 使用流式处理将列表 list 中的字符串按照它们的长度进行分组，并收集到一个新的 Map 中Map<Integer, List<String>> groupeds = list.stream()   // 将列表转换为一个流.collect(Collectors.groupingBy(fruit -> fruit.length())); // 使用 groupingBy() 方法按字符串长度进行分组System.out.println("Lambda分组：" + groupeds);}
}

执行结果

普通编码==》apple
普通编码==》orange
普通编码==》banana
Lambda遍历==》apple
Lambda遍历==》orange
Lambda遍历==》banana
普通排序：[apple, banana, orange]
Lambda排序：[apple, banana, orange]
普通过滤：[apple]
Lambda过滤：[banana]
普通映射：[5, 6, 6]
Lambda映射：[5, 6, 6]
普通归约15
Lambda归约15
普通分组：{5=[apple], 6=[banana, orange]}
Lambda分组：{5=[apple], 6=[banana, orange]}

7. 使用Lambda表达式进行函数式接口的实现

7.1 未使用Lambda表达式：

public interface MyInterface {public void doSomething(String input);
}MyInterface myObject = new MyInterface() {public void doSomething(String input) {System.out.println(input);}
};
myObject.doSomething("Hello World");

7.2 使用Lambda表达式：

MyInterface myObject = input -> System.out.println(input);
myObject.doSomething("Hello World");

Lambda表达式使得函数式接口的实现更加简洁，通过箭头操作符直接定义了函数的行为，减少了接口实现类的创建。

8. 使用Lambda表达式进行线程的创建

8.1 未使用Lambda表达式：

Thread thread = new Thread(new Runnable() {public void run() {System.out.println("Thread is running.");}
});
thread.start();

8.2 使用Lambda表达式：

Thread thread = new Thread(() -> System.out.println("Thread is running."));
thread.start();

Lambda表达式简化了线程的创建过程，使得代码更为紧凑、易读。

9. 使用Lambda表达式进行Optional的操作

9.1 未使用Lambda表达式：

String str = "Hello World";
if (str != null) {System.out.println(str.toUpperCase());
}

9.2 使用Lambda表达式：

Optional<String> str = Optional.ofNullable("Hello World");
str.map(String::toUpperCase).ifPresent(System.out::println);

Lambda表达式使得对Optional对象的操作更加直观，通过链式调用的方式简化了代码的编写。

10. 使用Lambda表达式进行Stream的流水线操作

10.1 未使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = new ArrayList<String>();
for (String fruit : list) {if (fruit.startsWith("a")) {filteredList.add(fruit.toUpperCase());}
}
Collections.sort(filteredList);

10.2 使用Lambda表达式：

List<String> list = Arrays.asList("apple", "banana", "orange");
List<String> filteredList = list.stream().filter(fruit -> fruit.startsWith("a")).map(String::toUpperCase).sorted().collect(Collectors.toList());

Lambda表达式简化了Stream流水线操作的代码，使得代码更为清晰、易读。

通过以上对比，我们可以清晰地看到Lambda表达式相比传统方式的优势，它使得代码更为简洁、可读，提高了编程效率。

🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🍁🐥

如对本文内容有任何疑问、建议或意见，请联系作者，作者将尽力回复并改进📓；(联系微信:Solitudemind )

点击下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。