• Lambda表达式超详细总结

    Lambda表达式介绍

    Java 8的一个大亮点是引入Lambda表达式，使用它设计的代码会更加简洁。通过Lambda表达式，可以替代我们以前经常写的匿名内部类来实现接口。Lambda表达式本质是一个匿名函数；

    体验Lambda表达式

    我们通过一个小例子来体验下Lambda表达式；

    我们定义一个计算接口，只有一个方法add；

    使用原始方式调用接口：

    1. public class LambdaTest {
    2.  
    3.     //定义一个cal接口
    4.     interface Cal {
    5.         int add(int a, int b);
    6.     }
    7.  
    8.     public static void main(String[] args) {
    9.         //使用原始方式调用接口
    10.         Cal cal = new Cal(){
    11.             @Override
    12.             public int add(int a, int b) {
    13.                 return a+b;
    14.             }
    15.         };
    16.         System.out.println("a+b等于："+cal.add(1,2));
    17.     }
    18. }

    这个是我们以前的实现，匿名内部类，然后调用执行；

    使用lambda表达式的方式：

    1. public class LambdaTest {
    2.  
    3.     //定义一个cal接口
    4.     interface Cal {
    5.         int add(int a, int b);
    6.     }
    7.  
    8.     public static void main(String[] args) {
    9.         //使用lambda表达式的方式
    10.         Cal cal = (int a,int b) ->{
    11.             return a+b;
    12.         };
    13.         System.out.println("a+b等于：" + cal.add(1, 2));
    14.         
    15.     }
    16. }

    匿名内部类，直接改成了：

    Cal cal = (int a,int b) ->{return a+b;};

    简洁多了；

    是不是感觉Lambda表达式挺强大，

    接下来我们来看看Lambda表达式的语法吧；

    Lambda表达式语法

    我们看下这个Lambda表达式：

    Cal cal = (int a,int b) ->{return a+b;};

    这个本质是一个函数；

    一般的函数类似如下：

    1. int add(int a,int b){
    2.   return a+b;
    3. }

    有返回值，方法名，参数列表，方法体

    Lambda表达式函数的话，只有参数列表，和方法体；

    ( 参数列表 ) -> { 方法体 }

    说明：

    ( ) ：用来描述参数列表；

    { } ： 用来描述方法体；

    ->  ：Lambda运算符，可以叫做箭头符号，或者goes to

    Lambda表达式语法细讲

    我们搞一个案例，接口方法参数，无参，单个参数，两个参数，有返回值，没有返回值；

    这六种情况都罗列下：

    1. interface If1{
    2.  
    3.     /**
    4.      * 无参数无返回值
    5.      */
    6.      void test();
    7. }
    8.  
    9.  
    10. interface If2{
    11.  
    12.     /**
    13.      * 单个参数无返回值
    14.      * @param a
    15.      */
    16.     void test(int a);
    17. }
    18.  
    19. interface If3{
    20.  
    21.     /**
    22.      * 两个参数无返回值
    23.      * @param a
    24.      * @param b
    25.      */
    26.     void test(int a,int b);
    27. }
    28.  
    29.  
    30. interface If4{
    31.  
    32.     /**
    33.      * 无参数有返回值
    34.      * @return
    35.      */
    36.     int test();
    37. }
    38.  
    39. interface If5{
    40.  
    41.     /**
    42.      * 单个参数有返回值
    43.      * @param a
    44.      * @return
    45.      */
    46.     int test(int a);
    47. }
    48.  
    49. interface If6{
    50.  
    51.     /**
    52.      * 多个参数有返回值
    53.      * @param a
    54.      * @param b
    55.      * @return
    56.      */
    57.     int test(int a,int b);
    58. }

    我们用Lambda表达式实现：

    1. /**
    2.          * 无参数无返回值
    3.          */
    4.         If1 if1 = ()->{
    5.             System.out.println("无参数无返回值...");
    6.         };
    7.         if1.test();
    8.  
    9.         /**
    10.          * 单个参数无返回值
    11.          * @param a
    12.          */
    13.         If2 if2 = (int a)->{
    14.             System.out.println("单个参数无返回值，a="+a);
    15.         };
    16.         if2.test(3);
    17.  
    18.         /**
    19.          * 两个参数无返回值
    20.          * @param a
    21.          * @param b
    22.          */
    23.         If3 if3 = (int a,int b)->{
    24.             System.out.println("单个参数无返回值，a+b="+(a+b));
    25.         };
    26.         if3.test(3,2);
    27.  
    28.         /**
    29.          * 无参数有返回值
    30.          * @return
    31.          */
    32.         If4 if4 = ()->{
    33.             System.out.print("无参数有返回值...");
    34.             return 100;
    35.         };
    36.         System.out.println(if4.test());
    37.  
    38.         /**
    39.          * 单个参数有返回值
    40.          * @param a
    41.          * @return
    42.          */
    43.         If5 if5 = (int a)->{
    44.             System.out.print("单个参数有返回值...");
    45.             return a;
    46.         };
    47.         System.out.println(if5.test(200));
    48.  
    49.         /**
    50.          * 多个参数有返回值
    51.          * @param a
    52.          * @param b
    53.          * @return
    54.          */
    55.         If6 if6 = (int a,int b)->{
    56.             System.out.print("多个参数有返回值...");
    57.             return a+b;
    58.         };
    59.         System.out.println(if6.test(2,3));

    运行输出：

    1. 无参数无返回值...
    2. 单个参数无返回值，a=3
    3. 单个参数无返回值，a+b=5
    4. 无参数有返回值...100
    5. 单个参数有返回值...200
    6. 多个参数有返回值...5

    Lambda表达式精简语法

    Lambda语法注意点：

    1,参数类型可以省略

    2,假如只有一个参数，()括号可以省略

    3,如果方法体只有一条语句，{}大括号可以省略

    4,如果方法体中唯一的语句是return返回语句，那省略大括号的同事return也要省略

    改写实例：

    1. /**
    2.          * 无参数无返回值
    3.          */
    4.         If1 if1 = () -> System.out.println("无参数无返回值...");
    5.         if1.test();
    6.  
    7.         /**
    8.          * 单个参数无返回值
    9.          * @param a
    10.          */
    11.         If2 if2 = a -> System.out.println("单个参数无返回值，a="+a);
    12.         if2.test(3);
    13.  
    14.         /**
    15.          * 两个参数无返回值
    16.          * @param a
    17.          * @param b
    18.          */
    19.         If3 if3 = (a,b) -> System.out.println("单个参数无返回值，a+b="+(a+b));
    20.         if3.test(3,2);
    21.  
    22.         /**
    23.          * 无参数有返回值
    24.          * @return
    25.          */
    26.         If4 if4 = () -> 100;
    27.         System.out.println(if4.test());
    28.  
    29.         /**
    30.          * 单个参数有返回值
    31.          * @param a
    32.          * @return
    33.          */
    34.         If5 if5 = a -> {
    35.             System.out.print("单个参数有返回值...");
    36.             return a;
    37.         };
    38.         System.out.println(if5.test(200));
    39.  
    40.         /**
    41.          * 多个参数有返回值
    42.          * @param a
    43.          * @param b
    44.          * @return
    45.          */
    46.         If6 if6 = (a,b) -> a+b;
    47.         System.out.println(if6.test(2,3));

    方法引用

    有时候多个lambda表达式实现函数是一样的话，我们可以封装成通用方法，以便于维护；

    这时候可以用方法引用实现：

    语法是：对象::方法

    假如是static方法，可以直接 类名::方法

    实例如下：

    1. interface If5{
    2.         /**
    3.          * 单个参数有返回值
    4.          * @param a
    5.          * @return
    6.          */
    7.         int test(int a);
    8.     }
    9.  
    10.     public int test(int a){
    11.         return a-2;
    12.     }
    13.     
    14.     public static void main(String[] args) {
    15.         LambdaTest3 lambdaTest3 = new LambdaTest3();
    16.         If5 if5 = lambdaTest3::test;
    17.         System.out.println("单个参数有返回值："+if5.test(3));
    18.     }

    构造方法引用

    如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现，

    那么就可以使用构造方法引用;

    语法：类名::new

    实例：

    先定义一个Dog实体，实现无参和有参构造方法；

    1. public class Dog {
    2.  
    3.     private String name;
    4.  
    5.     private int age;
    6.  
    7.     public Dog() {
    8.         System.out.println("无参构造方法");
    9.     }
    10.  
    11.     public Dog(String name, int age) {
    12.         System.out.println("有参构造方法");
    13.         this.name = name;
    14.         this.age = age;
    15.     }
    16.  
    17.  
    18.     public String getName() {
    19.         return name;
    20.     }
    21.  
    22.     public void setName(String name) {
    23.         this.name = name;
    24.     }
    25.  
    26.     public int getAge() {
    27.         return age;
    28.     }
    29.  
    30.     public void setAge(int age) {
    31.         this.age = age;
    32.     }
    33.  
    34.     @Override
    35.     public String toString() {
    36.         return "Dog{" +
    37.                 "name='" + name + '\'' +
    38.                 ", age=" + age +
    39.                 '}';
    40.     }
    41. }

    在定义两个接口：

    1. interface DogService{
    2.     Dog getDog();
    3.  
    4. }
    5.  
    6. interface DogService2{
    7.     Dog getDog(String name,int age);
    8. }

    测试：

    1. //普通方式
    2.         DogService dogService=()->{
    3.             return new Dog();
    4.         };
    5.         dogService.getDog();
    6.  
    7.         //简化方式
    8.         DogService dogService1=()->new Dog();
    9.         dogService1.getDog();
    10.  
    11.         //构造方法引用
    12.         DogService dogService2=Dog::new;
    13.         dogService2.getDog();
    14.  
    15.         // 构造方法引用 有参
    16.         DogService2 dogService3=Dog::new;
    17.         dogService3.getDog("小米",11);

    执行结果：

    1. 无参构造方法
    2. 无参构造方法
    3. 无参构造方法
    4. 有参构造方法

    综合实例

    下面我们通过几个lambda操作集合的综合实例，来深入体验下Lambda表达式用法；

    Lambda表达式排序：

    1. //定义一个List集合
    2. List list=new ArrayList<>();
    3. //往集合中添加值
    4. list.add(new Dog("aa",1));
    5. list.add(new Dog("bb",4));
    6. list.add(new Dog("cc",3));
    7. list.add(new Dog("dd",2));
    8. list.add(new Dog("ee",5));
    9. //排序
    10. System.out.println("lambda集合排序：");
    11. list.sort((o1, o2) -> o1.getAge()-o2.getAge());
    12. System.out.println(list);
    13. // 遍历集合
    14. System.out.println("lambda遍历集合：");
    15. list.forEach(System.out::println);

    运行输出：

    1. lambda集合排序：
    2. [Dog{name='aa', age=1}, Dog{name='dd', age=2}, Dog{name='cc', age=3}, Dog{name='bb', age=4}, Dog{name='ee', age=5}]
    3. lambda遍历集合：
    4. Dog{name='aa', age=1}
    5. Dog{name='dd', age=2}
    6. Dog{name='cc', age=3}
    7. Dog{name='bb', age=4}
    8. Dog{name='ee', age=5}

    我们来分析下集合的sort方法，

    sort方法里有一个Comparator接口，再点进去看下：

    我们通过lambda就可以轻松实现排序：

    (o1,o2)->o1.getAge()-o2.getAge()

    再看下集合的forEach方法，点进去：

    有个消费者Consumer接口，再点进去：

    接口里有个接口参数的accept的方法；

    所以我们直接方法引用 直接输出每次的遍历值即可；

    System.out::println

    @FunctionalInterface注解

    前面我们会发现Consumer接口，Comparator接口都有@FunctionalInterface注解；

    这个注解是函数式接口注解，所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。

    这种类型的接口也称为SAM接口，即Single Abstract Method interfaces

    特点：

    1、接口有且仅有一个抽象方法

    2、允许定义静态方法

    3、允许定义默认方法

    4、允许java.lang.Object中的public方法

    5、该注解不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响。加上该注解能够更好地让编译器进行检查。如果编写的不是函数式接口，但是加上了@FunctionInterface，那么编译器会报错

    实例：

    1. // 正确的函数式接口
    2. @FunctionalInterface
    3. public interface TestInterface {
    4.  
    5.     // 抽象方法
    6.     public void sub();
    7.  
    8.     // java.lang.Object中的public方法
    9.     public boolean equals(Object var1);
    10.  
    11.     // 默认方法
    12.     public default void defaultMethod(){
    13.     
    14.     }
    15.  
    16.     // 静态方法
    17.     public static void staticMethod(){
    18.  
    19.     }
    20. }
    21.  
    22. // 错误的函数式接口(有多个抽象方法)
    23. @FunctionalInterface
    24. public interface TestInterface2 {
    25.  
    26.     void add();
    27.     
    28.     void sub();
    29. }

    系统内置函数式接口

    Java8的推出，是以Lambda重要特性，一起推出的，其中系统内置了一系列函数式接口；

    在jdk的java.util.function包下，有一系列的内置函数式接口：

    比如常用的Consumer，Comparator，Predicate，Supplier等；

    Lambda表达式视频教程

    B站视频教程在线地址：

    Java8 Lambda表达式视频教程(无废话版)_哔哩哔哩_bilibili

  • 相关阅读:
    Ext Direct 开发全介绍
    算法导论第一章——算法在计算中的应用
    基于云计算与深度学习的常见作物害虫识别系统的设计与实现
    我代码就加了一行 log 日志，结果引发了 P1 的线上事故
    码云gitee+宝塔webhook实现同步代码
    【建议背诵】软考高项考试案例简答题汇总~（7）
    Python 图形化界面基础篇：使用网格布局（ Grid Layout ）排列元素
    1230: 蜂巢
    C++中有哪些常用的算法和数据结构？
    Libgdx游戏开发(6)——游戏暂停
  • 原文地址：https://blog.csdn.net/weixin_55076626/article/details/127830494