• Lambda 表达式详解

    Lambda
    LAMBDA

    ⚪ λ 希腊字母表中排序第十一位的字母, 英语名称为Lambda

    ⚪ 避免匿名内部类定义过多

    ⚪ 其实质属于函数式编程的概念

    ⚪ 也可称为闭包

    ⚪ Lambda允许把一个函数作为方法的参数（函数作为参数传递进方法中）。

    Lambda是在jdk8之后出现的所以现在用到的还是比较多的, 需要学习

    ◻️ 为什么要使用Lambda表达式 

       ◽避免匿名内部类定义过多

       ◽可以使代码更加简洁紧凑

       ◽去掉了一堆没有意义的代码, 只留下核心的逻辑。

    💬 也许你会说, 我看了Lambda表达式, 不但不觉得简洁, 反而觉得更乱了, 看不懂了. 那是因为我们还没有习惯, 用的多了, 看习惯了, 就好了。学习就是这样的一个过程

    语法

    lambda 表达式的语法格式如下：

    1. (parameters) -> expression [表达式]
    2. 或
    3. (parameters) -> statement [语句]
    4. 或
    5. (parameters) -> { statements; }
    a-> System.out.println("i like lambda-->"+a)

    ◻️ 理解Functional Interface (函数式接口) 是学习Java8 lambda表达式的关键所在。

     函数式接口定义:

       ◽任何接口, 如果只包含唯一一个抽象方法, 那么它就是一个函数式接口。

    1. public interface Runnable {
    2.    public abstract void run(); //抽象方法
    3. }

       ◽对于函数式接口, 我们可以通过 Lambda表达式 来创建该接口的对象。

    如果到这里某些小伙伴还是听不懂的话, 没关系, 我们上代码推动着你讲解一下你就懂了:

    Lambda表达式推导

    1. 首先需要定义一个函数式接口

    2. 实现接口的方法 → 一步一步简化方式实现

    •      第一个实现方法  :创建实现类, 实现
    •      第二个实现方法  :静态内部类, 实现
    •      第三个实现方法  :局部内部类, 实现
    •      第四个实现方法  :匿名内部类, 实现
    •      第五个实现方法  :Lambda表达式, 实现

    3. 创建接口对象  接口调用实现类

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  10:52
    8.  * @Description: TODO: 推导 Lambda表达式
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda {
    12. //    3. 静态内部类
    13.     static class Like2 implements ILike{
    14.     @Override
    15.     public void lambda() {
    16.         System.out.println("i like lambda2");
    17.     }
    18. }
    19.  
    20. //    3. main
    21.     public static void main(String[] args) {
    22. //        3. 创建接口对象  接口调用实现类
    23.         ILike like = new Like();
    24.         like.lambda();
    25.  
    26.         like = new Like2();
    27.         like.lambda();
    28.  
    29.  
    30. //       4. 局部内部类
    31.  
    32.         class Like3 implements ILike {
    33.             @Override
    34.             public void lambda() {
    35.                 System.out.println("i like lambda3");
    36.             }
    37.         }
    38.  
    39.         like = new Like3();
    40.         like.lambda();
    41.  
    42. //        5. 匿名内部类, 没有类的名称,必须借助接口或者父类
    43.         like = new Like() {
    44.             @Override
    45.             public void lambda() {
    46.                 System.out.println("i like lambda4");
    47.             }
    48.         };
    49.         like.lambda();
    50.  
    51. //        6. 用Lambda简化 Lambda是在jdk8之后出现的所以现在用到的还是比较多的, 需要学习
    52.         like = ()-> {
    53.             System.out.println("i like lambda5");
    54.         };
    55.         like.lambda();
    56.     }
    57. }
    58.  
    59. //1. 首先需要定义一个函数式接口
    60. interface ILike {
    61.     void lambda();
    62. }
    63.  
    64. //2. 实现类, 实现lambda方法
    65. class Like implements ILike {
    66.     @Override
    67.     public void lambda() {
    68.         System.out.println("i like lambda");
    69.     }
    70. }

    如果你还是不理解那我们再来写一个例子

     我们可以看到我们以上代码定义的函数式接口是没有参数的, 那我们来写一个不同的例子, 带参数的函数式接口.

    这次我们一个方式一个方式的写, 看着不会太乱, 更好理解

    Lambda表达式推导详解

    这里我们定义了一个int类型的参数

    1. 定义一个带参数的函数接口 

    2. 实现接口方法

    3. 创建接口对象  接口调用实现类

    4. 传递参数

    • 第一个实现方法  :创建实现类, 实现

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  12:11
    8.  * @Description: TODO
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda2 {
    12.  
    13.     public static void main(String[] args) {
    14. //    创建接口对象
    15.         ILove love = new Love();
    16. //    传递参数
    17.         love.love(2);
    18.     }
    19. }
    20.  
    21. // 1. 定义一个带参数的函数式接口
    22. interface ILove {
    23.     void love(int a);  //定义一个int类型的参数
    24. }
    25.  
    26. //2. 实现类
    27. class Love implements ILove {
    28.     @Override
    29.     public void love(int a) {
    30.         System.out.println("i love you--->" + a);
    31.     }
    32. }

    •      第二个实现方法  :静态内部类, 实现 

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  12:11
    8.  * @Description: TODO
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda2 {
    12.  
    13.     //2. 静态实现类
    14.     static class Love implements ILove {
    15.         @Override
    16.         public void love(int a) {
    17.             System.out.println("i love you--->" + a);
    18.         }
    19.  
    20.         public static void main(String[] args) {
    21. //    实现love接口
    22.             ILove love = new Love();
    23. //    传递参数
    24.             love.love(2);
    25.         }
    26.     }
    27. }
    28.  
    29.  
    30. // 1. 定义一个带参数的函数式接口
    31. interface ILove {
    32.     void love(int a);  //定义一个int类型的参数
    33. }

    •      第三个实现方法  :局部内部类, 实现

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  12:11
    8.  * @Description: TODO
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda2 {
    12.  
    13.         public static void main(String[] args) {
    14.             //2. 局部内部类
    15.              class Love implements ILove {
    16.                  @Override
    17.                  public void love(int a) {
    18.                      System.out.println("i love you--->" + a);
    19.                  }
    20.              }
    21. //    实现love接口
    22.             ILove love = new Love();
    23. //    传递参数
    24.             love.love(2);
    25.         }
    26.     }
    27.  
    28.  
    29. // 1. 定义一个带参数的函数式接口
    30. interface ILove {
    31.     void love(int a);  //定义一个int类型的参数
    32. }

         

    • 第四个实现方法  :匿名内部类, 实现

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  12:11
    8.  * @Description: TODO
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda2 {
    12.  
    13.         public static void main(String[] args) {
    14. //    实现love接口
    15. //          匿名内部类
    16.             ILove love = new ILove(){
    17.                 @Override
    18.                 public void love(int a) {
    19.  
    20.                 }
    21.             };
    22. //    传递参数
    23.             love.love(2);
    24.         }
    25.     }
    26.  
    27.  
    28. // 1. 定义一个带参数的函数式接口
    29. interface ILove {
    30.     void love(int a);  //定义一个int类型的参数
    31. }

    匿名内部实现类推导再简化, 就是我们的Lambda表达式.

    •       第五个实现方法  :Lambda表达式, 实现

    如下图:

    基于匿名内部类代码小编圈起来的代码都不用要了直接删掉!

    • 只留下我们的参数和主体  就是我们的lambda表达式了

    参数: int a;

    主体: System.out.println()

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  12:11
    8.  * @Description: TODO
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda2 {
    12.  
    13.         public static void main(String[] args) {
    14. //    实现love接口
    15. //          lambda表达式实现
    16.             ILove love = (int a)-> {
    17.                 System.out.println("i love lambda表达式");
    18.             };
    19. //    传递参数
    20.             love.love(2);
    21.         }
    22.     }
    23.  
    24.  
    25. // 1. 定义一个带参数的函数式接口
    26. interface ILove {
    27.     void love(int a);  //定义一个int类型的参数
    28. }

    那有些小伙伴就要问了:

    💬 :既然可以简化这么多, 我们还能不能对它再简化呢?

    👩‍💻:没问题

    而且小编给大家扩充一下, Lambda表达式可以实现3种简化.但是也有条件的

    简化 Lambda表达式

    • 简化方式一:

    1. 简化掉参数类型

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  12:11
    8.  * @Description: TODO
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda2 {
    12.  
    13.         public static void main(String[] args) {
    14. //    实现love接口
    15.             ILove love=null;
    16. //          lambda表达式实现
    17.             love = (int a)-> {
    18.                 System.out.println("i love lambda表达式");
    19.             };
    20.  
    21. //            Lambda表达式简化 1, 参数类型
    22.             love = (a)-> {
    23.                 System.out.println("i love lambda表达式");
    24.             };
    25.  
    26. //    传递参数
    27.             love.love(2);
    28.         }
    29.     }
    30.  
    31.  
    32. // 1. 定义一个带参数的函数式接口
    33. interface ILove {
    34.     void love(int a);  //定义一个int类型的参数
    35. }

    •  简化方式二:

    2. 简化掉参数类型+括号

    前提:

    只有一个参数的情况下才可以去掉括号, 多个参数会报错. 加上括号即可

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  12:11
    8.  * @Description: TODO
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda2 {
    12.  
    13.         public static void main(String[] args) {
    14. //    实现love接口
    15.             ILove love=null;
    16. //          lambda表达式实现
    17.             love = (int a)-> {
    18.                 System.out.println("i love lambda表达式");
    19.             };
    20.  
    21. //            Lambda表达式简化 1, 参数类型
    22.             love = (a)-> {
    23.                 System.out.println("i love lambda表达式");
    24.             };
    25.  
    26. //            Lambda表达式简化 2, 简化括号
    27.             love = a-> {
    28.                 System.out.println("i love lambda表达式");
    29.             };
    30.  
    31. //    传递参数
    32.             love.love(2);
    33.         }
    34.     }
    35.  
    36.  
    37. // 1. 定义一个带参数的函数式接口
    38. interface ILove {
    39.     void love(int a);  //定义一个int类型的参数
    40. }

    •   简化方式三:

    2. 简化掉参数类型+括号+花括号

    前提:

    只有一行代码的情况下

    多个参数不能使用, 会报错 多个参数需要加上括号

    1. package cn.lambda;
    2.  
    3. /**
    4.  * @BelongsProject: staticthread
    5.  * @BelongsPackage: cn.lambda
    6.  * @Author: Jean_z
    7.  * @CreateTime: 2024-05-14  12:11
    8.  * @Description: TODO
    9.  * @Version: 1.0
    10.  */
    11. public class TestLambda2 {
    12.  
    13.         public static void main(String[] args) {
    14. //    实现love接口
    15.             ILove love=null;
    16. //          lambda表达式实现
    17.             love = (int a)-> {
    18.                 System.out.println("i love lambda表达式");
    19.             };
    20.  
    21. //            Lambda表达式简化 1, 参数类型
    22.             love = (a)-> {
    23.                 System.out.println("i love lambda表达式");
    24.             };
    25.  
    26. //            Lambda表达式简化 2, 简化括号
    27.             love = a-> {
    28.                 System.out.println("i love lambda表达式");
    29.             };
    30.  
    31. //            Lambda表达式简化 3, 简化花括号
    32.             love = a-> System.out.println("i love lambda表达式" + a);
    33.  
    34. //    传递参数
    35.             love.love(2);
    36.         }
    37.     }
    38.  
    39.  
    40. // 1. 定义一个带参数的函数式接口
    41. interface ILove {
    42.     void love(int a);  //定义一个int类型的参数
    43. }

    总结:

    lambda表达式只能有一行代码的情况下才能简化成为一行, 如果有多行, 那就么就用代码块包裹.

    前提是接口为函数时接口.

    多个参数也可以去掉参数类型, 要去掉就全去掉, 必须加括号

  • 相关阅读:
    ArrayList、LinkedList、Collections.singletonList、Arrays.asList与ImmutableList.of
    基于SSM 离退休管理平台-计算机毕设 附源码 52629
    【强化学习】Sarsa算法求解悬崖行走问题 + Python代码实战
    【Arduino+ESP32专题】串口的简单使用
    CentOS7 k3s安装与配置
    vue常用修饰符-- stop,prevent,.enter,once,lazy,number,trim
    工具、技巧【个人专用】如何在CSND编辑器内输出带颜色的字体？Markdown编辑器——字体、字号、颜色使用全解
    Layui之动态树
    ESP32编译出现Cannot establish a connection to the component registry.报错
    Codeforces Round #712 (Div. 1) A. Balance the Bits
  • 原文地址：https://blog.csdn.net/zzx_mn/article/details/138843255