Lambda 表达式的语法与使用：更简洁、更灵活的函数式编程！

开篇语

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云/阿里云/华为云/51CTO；欢迎大家常来逛逛

  今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

  我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

Lambda 表达式的语法与使用：更简洁、更灵活的函数式编程

  Lambda 表达式是 Java 8 引入的一个强大特性，它使得 Java 更加简洁、灵活，尤其是在处理集合、事件和回调时，能够以更加函数式的方式表达代码。Lambda 表达式的引入是 Java 语言的一次重大变革，它不仅让代码更加简洁，也增强了 Java 语言的表达力和可维护性。

一、Lambda 表达式的语法

Lambda 表达式的基本语法如下：

(parameters) -> expression

其中：

• parameters：表示传递给 Lambda 表达式的参数，类似于方法的参数列表。
• ->：Lambda 操作符，用于将参数列表与方法体分隔开。
• expression：Lambda 表达式的主体，表示 Lambda 执行的代码。它可以是单行的表达式，也可以是包含多行的代码块。

1.1 Lambda 表达式的基本语法形式

1. 无参数，返回值为空：

   () -> System.out.println("Hello, World");
   

   这表示一个没有参数且执行简单操作的 Lambda 表达式。

2. 一个参数，返回值：

   x -> x * x
   

   这是一个接受单个参数并返回其平方的 Lambda 表达式。

3. 多个参数：

   (x, y) -> x + y
   

   这是一个接受两个参数并返回它们和的 Lambda 表达式。

4. 包含代码块：

   (x, y) -> {
       int sum = x + y;
       return sum;
   }
   

   这是一个包含多行代码的 Lambda 表达式，其中 return 用于返回结果。

二、Lambda 表达式的使用

Lambda 表达式可以应用于任何需要函数式接口的场景，函数式接口是只包含一个抽象方法的接口。例如，Java 提供的 Runnable、Callable、Comparator 等接口都可以使用 Lambda 表达式来实现。

2.1 Lambda 表达式与匿名内部类的对比

在 Java 中，Lambda 表达式常常用来替代匿名内部类，尤其是在实现接口时。与匿名内部类相比，Lambda 表达式更加简洁。

代码示例：使用匿名内部类和 Lambda 表达式实现 Runnable 接口

匿名内部类实现：

public class RunnableExample {
    public static void main(String[] args) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello from anonymous class");
            }
        };
        new Thread(runnable).start();
    }
}

Lambda 表达式实现：

public class RunnableExample {
    public static void main(String[] args) {
        Runnable runnable = () -> System.out.println("Hello from Lambda");
        new Thread(runnable).start();
    }
}

  在这个例子中，使用 Lambda 表达式代替匿名内部类，使得代码更加简洁。

2.2 Lambda 表达式与函数式接口

Lambda 表达式的目标是函数式接口。一个接口如果只包含一个抽象方法，就称为函数式接口。例如，Runnable、Callable 和 Comparator 都是函数式接口。

代码示例：自定义函数式接口

@FunctionalInterface
interface Calculator {
    int add(int a, int b);
}

public class LambdaExample {
    public static void main(String[] args) {
        // 使用 Lambda 表达式实现函数式接口
        Calculator calculator = (a, b) -> a + b;
        System.out.println("Sum: " + calculator.add(5, 3));
    }
}

  在这个例子中，我们定义了一个 Calculator 函数式接口，它有一个 add 方法。然后，我们使用 Lambda 表达式来实现 add 方法。

三、常用的 Lambda 表达式场景

3.1 在集合框架中的使用

Lambda 表达式特别适用于集合框架（如 List、Set、Map）的操作，常见的操作包括遍历、过滤、排序等。Java 8 引入的 Stream API 使得对集合的操作更加直观。

代码示例：使用 Lambda 表达式遍历集合

import java.util.Arrays;
import java.util.List;

public class LambdaForEachExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Apple", "Banana", "Cherry");

        // 使用 Lambda 表达式遍历集合
        list.forEach(item -> System.out.println(item));
    }
}

  在这个例子中，我们使用 forEach 方法和 Lambda 表达式遍历列表，并打印每个元素。

3.2 过滤与映射

通过 Stream API，Lambda 表达式还可以用于对集合元素的过滤、映射和聚合操作。

代码示例：使用 Lambda 表达式过滤与映射

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class LambdaFilterMapExample {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        // 使用 Lambda 表达式过滤偶数，并将每个数乘以 2
        List<Integer> result = numbers.stream()
                                      .filter(n -> n % 2 == 0)
                                      .map(n -> n * 2)
                                      .collect(Collectors.toList());

        System.out.println(result);  // 输出：[4, 8, 12]
    }
}

  在这个例子中，我们使用 filter() 方法来过滤偶数，使用 map() 方法将每个数乘以 2，然后通过 collect() 方法将结果转换成一个新的列表。

3.3 排序操作

Lambda 表达式还可以与 Comparator 一起使用，简化排序操作。

代码示例：使用 Lambda 表达式排序

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;

public class LambdaSortExample {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Banana", "Apple", "Cherry");

        // 使用 Lambda 表达式进行排序
        list.sort((a, b) -> a.compareTo(b));  // 升序排序
        System.out.println(list);  // 输出：[Apple, Banana, Cherry]
    }
}

  在这个例子中，我们使用 sort() 方法和 Lambda 表达式来对字符串列表进行排序。

四、函数式编程与 Lambda 表达式

Lambda 表达式是 Java 函数式编程的核心，允许我们将函数作为参数传递并返回。Java 8 的 Function、Predicate、Consumer 和 Supplier 等接口是函数式编程的关键组成部分。

4.1 Function 接口

Function 接口代表接受一个参数并返回一个结果的函数。

代码示例：使用 Function 接口

import java.util.function.Function;

public class FunctionExample {
    public static void main(String[] args) {
        Function<String, Integer> stringLength = str -> str.length();
        System.out.println(stringLength.apply("Hello"));  // 输出：5
    }
}

4.2 Predicate 接口

Predicate 接口用于判断某个条件是否成立。

代码示例：使用 Predicate 接口

import java.util.function.Predicate;

public class PredicateExample {
    public static void main(String[] args) {
        Predicate<Integer> isEven = n -> n % 2 == 0;
        System.out.println(isEven.test(4));  // 输出：true
    }
}

4.3 Consumer 接口

Consumer 接口表示接受一个参数并执行某些操作，但不返回结果。

代码示例：使用 Consumer 接口

import java.util.function.Consumer;

public class ConsumerExample {
    public static void main(String[] args) {
        Consumer<String> print = str -> System.out.println(str);
        print.accept("Hello, World!");  // 输出：Hello, World!
    }
}

五、总结：Lambda 表达式的优势与应用

Lambda 表达式使 Java 的代码更加简洁、清晰和函数式。通过 Lambda 表达式，我们能够：

• 简化匿名内部类的使用，特别是在实现函数式接口时。
• 与 Stream API 一起，使得对集合的操作（如过滤、映射、排序等）更加简洁和高效。
• 提高代码的可读性和可维护性。

Lambda 表达式在 Java 8 中的引入是 Java 语言的一次重大改进，它使得 Java 更加符合现代编程范式，尤其是在处理集合和事件时，能够提供更简洁、直观的表达方式。

… …

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。
⭐️若有疑问，就请评论留言告诉我叭。

版权声明：本文由作者原创，转载请注明出处，谢谢支持！