Java Lambda表达式：简化编程，提高效率

- 1. 使用Lambda表达式进行集合遍历
- - 1.1 未使用Lambda表达式：
  - 1.2 使用Lambda表达式：
- 2. 使用Lambda表达式进行排序
- - 2.1 未使用Lambda表达式：
  - 2.2 使用Lambda表达式：
- 3. 使用Lambda表达式进行过滤
- - 3.1 未使用Lambda表达式：
  - 3.2 使用Lambda表达式：
- 4. 使用Lambda表达式进行映射
- - 4.1 未使用Lambda表达式：
  - 4.2 使用Lambda表达式：
- 5. 使用Lambda表达式进行归约
- - 5.1 未使用Lambda表达式：
  - 5.2 使用Lambda表达式：
- 6. 使用Lambda表达式进行分组
- - 6.1 未使用Lambda表达式：
  - 6.2 使用Lambda表达式：
- 源码
- 7. 使用Lambda表达式进行函数式接口的实现
- - 7.1 未使用Lambda表达式：
  - 7.2 使用Lambda表达式：
- 8. 使用Lambda表达式进行线程的创建
- - 8.1 未使用Lambda表达式：
  - 8.2 使用Lambda表达式：
- 9. 使用Lambda表达式进行Optional的操作
- - 9.1 未使用Lambda表达式：
  - 9.2 使用Lambda表达式：
- 10. 使用Lambda表达式进行Stream的流水线操作
- - 10.1 未使用Lambda表达式：
  - 10.2 使用Lambda表达式：

在这里插入图片描述

博主默语带您 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 方法
            @Override
            public 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() 方法对流中的元素进行累加求和，初始值为 0

        System.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());