找回密码
 加入我们
关闭

CSDN热搜

草根吧
首页 官方推荐社区 编程语言 Java中的Lambda表达式

python Java中的Lambda表达式

IP:广东省广州市
名名 2023-12-3 09:53:31
lambda表达式是一个可传递的代码块,可以在今后尝试一次或屡次。
1.lambda表达式的语法

eg:有以下lambda表达式:
(int a, int b) -> {return a+b};
这个表达式的本质是一个函数。
一样平常的函数类似以下:
  1. int add(int a, int b) {
  2.     return a+b;
  3. }
复制代码
有返回值、方式名、参数列表、方式体。
而Lambda表达式只要参数列表和方式体:
(参数列表)->{方式体}
说明:


  • () :用来描摹参数列表;
  • {} :用来描摹方式体;
  • -> :Lambda运算符可以叫做箭头标记,大概 goes to(指向);
2.函数式接口

对于只要一个笼统方式的接口,需要这类接口的工具时,便可以供给一个lambda表达式。这类接口叫做函数式接口。
经过操纵lambda表达式展现利用处景。
  1. public class Lambda {
  2.     public static void main(String[] args) {
  3.         If1 if1 = ()->{
  4.             System.out.println("无参无返回值");
  5.         };
  6.         //挪用方式
  7.         if1.test();
  8.         If2 if2 = (int a)->{
  9.             System.out.println("单个参数无返回值:a = " + a);
  10.         };
  11.         if2.test(2);
  12.         If3 if3 = (int a, int b)->{
  13.             System.out.println("两个参数无返回值:a + b = " + (a + b));
  14.         };
  15.         if3.test(1, 2);
  16.         If4 if4 = ()->{
  17.           return 4;
  18.         };
  19.         System.out.println("无参有返回值,返回值为:" + if4.test());
  20.         If5 if5 = (int a)->{
  21.           return a;
  22.         };
  23.         System.out.println("有参有返回值,返回值为:a = " + if5.test(5));
  24.     }
  25.     //无参无返回值
  26.     interface If1 {
  27.         void test();
  28.     }
  29.     //单个参数无返回值
  30.     interface If2{
  31.         void test(int a);
  32.     }
  33.     //两个参数无返回值
  34.     interface If3{
  35.         void test(int a, int b);
  36.     }
  37.     //无参有返回值
  38.     interface If4{
  39.         int test();
  40.     }
  41.     //有参有返回值
  42.     interface If5{
  43.         int test(int a);
  44.     }
  45. }
复制代码
运转结果如图:

关于以下代码的题目:
  1.         If1 if1 = ()->{
  2.             System.out.println("无参无返回值");
  3.         };
  4.         //挪用方式
  5.         if1.test();
复制代码
在上述代码中,If1不是一个接口吗?为什么可以有工具if1呢?
现实上这里是操纵了lambda来实现匿名内部类的感化,以下:
  1.         If1 if1 = new If1() {
  2.             @Override
  3.             public void test() {
  4.                 System.out.println("无参无返回值");
  5.             }
  6.         };
  7.         //挪用方式
  8.         if1.test();
复制代码
而匿名内部类写成一般的实现类就是类实现If1接口然后建立if1类工具,代码以下:
  1. //界说接口
  2. interface If1{
  3.     void test();
  4. }
  5. //实现了接口的类
  6. class NiMing implements If1{
  7.     void test() {
  8.             System.out.println("无参数无返回值");
  9.     }
  10. }
  11. //建立类工具
  12. public class Test{
  13.     NiMing if1 = new NiMing();
  14. }
复制代码
3.lambda表达式精简语法



  • 参数典范可以省略
  • 假如只要一个参数,()括号可以省略
  • 假如方式体只要一条语句,{}大括号可以省略
  • 假如方式体中唯逐一条语句是return返回语句,那末省略大括号的同时return也要省略(只省略return,不省略全部return语句)
    实例代码以下:
  1. public class Lambda2 {    public static void main(String[] args) {        //无参数()括号不能省略        If1 if1 = ()->{
  2.             System.out.println("无参无返回值");
  3.         };
  4.         //挪用方式
  5.         if1.test();
  6.         //单个参数,参数典范和()括号可以省略        //方式体内单个语句{}大括号可以省略        If2 if2 = a-> System.out.println("单个参数无返回值:a = " + a);        if2.test(2);        If3 if3 = (a, b)-> System.out.println("两个参数无返回值:a + b = " + (a + b));        if3.test(1, 2);        //省略return和{}大括号        If4 if4 = ()->4;        System.out.println("无参有返回值,返回值为:" + if4.test());        If5 if5 = a->a;        System.out.println("有参有返回值,返回值为:a = " + if5.test(5));    }    //无参无返回值    interface If1 {        void test();    }    //单个参数无返回值    interface If2{        void test(int a);    }    //两个参数无返回值    interface If3{        void test(int a, int b);    }    //无参有返回值    interface If4{        int test();    }    //有参有返回值    interface If5{        int test(int a);    }}
复制代码
运转结果以下:

4.方式援用

偶然间多个lambda表达式实现的函数是一样的话,可以封装成通用方式,以便于保护;
这个时候可以用方式援用实现:
语法是:工具::方式
假如是static静态方式,可以间接 类名::方式
4.1非静态方式的方式援用

示例代码以下:
  1. public class Lambda3 {
  2.     public static void main(String[] args) {
  3.         If if1 = a -> a-2;
  4.         System.out.println("if1的返回值为: " + if1.test(3));
  5.         If if2 = a -> a-2;
  6.         System.out.println("if2的返回值为: " + if2.test(4));
  7.     }
  8.     //单个参数有返回值
  9.     interface If{
  10.         int test(int a);
  11.     }
  12. }
复制代码
可以看到两个工具挪用的是同一种方式,所以可以操纵方式援用来替换,代码以下:
  1. public class Lambda3 {
  2.     public static void main(String[] args) {
  3. //        If if1 = a -> a-2;
  4. //        System.out.println("if1的返回值为: " + if1.test(3));
  5. //
  6. //        If if2 = a -> a-2;
  7. //        System.out.println("if2的返回值为: " + if2.test(4));
  8.         //建立工具
  9.         Lambda3 lambda3 = new Lambda3();
  10.         //操纵lambda表达式援用方式
  11.         If if1 = lambda3::testA;
  12.         System.out.println("if1的返回值为: " + if1.test(3));
  13.         If if2 = lambda3::testA;
  14.         System.out.println("if2的返回值为: " + if2.test(4));
  15.     }
  16.     public int testA(int a) {
  17.         return a-2;
  18.     }
  19.     //单个参数有返回值
  20.     interface If{
  21.         int test(int a);
  22.     }
  23. }
复制代码
现实上testA实现的也是接口If中的方式。
4.2静态方式的方式援用

间接操纵 类名::方式
  1. public class Lambda4 {
  2.     public static void main(String[] args) {
  3.         //操纵lambda表达式援用方式
  4.         If if1 = Lambda4::testA;
  5.         System.out.println("if1的返回值为: " + if1.test(3));
  6.         If if2 = Lambda4::testA;
  7.         System.out.println("if2的返回值为: " + if2.test(4));
  8.     }
  9.     //静态方式
  10.     public static int testA(int a) {
  11.         return a-2;
  12.     }
  13.     //单个参数有返回值
  14.     interface If{
  15.         int test(int a);
  16.     }
  17. }
复制代码
5.机关方式援用

假如函数式接口的实现恰好可以经过挪用一个类的机关方式来实现,那末便可以操纵机关方式援用。
语法: 类名::new
实例代码以下:
首先界说一个Dog类:
  1. public class Dog {
  2.     private String name;
  3.     private int age;
  4.     //无参机关方式
  5.     public Dog(){}
  6.     //有参机关方式
  7.     public Dog(String name, int age) {
  8.         this.name = name;
  9.         this.age = age;
  10.     }
  11.     public String getName() {
  12.         return this.name;
  13.     }
  14.     public int getAge() {
  15.         return this.age;
  16.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  20.     public void setAge(int age) {
  21.         this.age = age;
  22.     }
  23. //重写toString方式
  24.     public String toString() {
  25.         return "Dog{" + "name='" + name + '\'' +
  26.                 ", age=" + age + '}';
  27.     }
  28. }
复制代码
然后测试机关方式援用:
  1. public class Lambda5 {
  2.     public static void main(String[] args) {
  3. //        //传统方式
  4. //        //无参
  5. //        DogService1 dog1 = () -> {
  6. //          return new Dog();
  7. //        };
  8. //        System.out.println(dog1.getDog());
  9. //        //简化版本
  10. //        DogService1 dog1 = () -> new Dog();
  11. //        System.out.println(dog1.getDog());
  12.         //机关方式援用
  13.         //无参
  14.         DogService1 dog1 = Dog::new;
  15.         System.out.println(dog1.getDog());
  16.         //有参
  17.         DogService2 dog2 = Dog::new;
  18.         System.out.println(dog2.getDog("小汪", 1));
  19.     }
  20.     interface DogService1{
  21.         Dog getDog();   //无参
  22.     }
  23.     interface DogService2{
  24.         Dog getDog(String name, int age);   //有参
  25.     }
  26. }
复制代码
免责声明:本文章来自网友分享,假如加害了您的权益,请联系我们,我们会实时删除侵权内容,感谢合作!

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?加入我们

x

使用道具 举报

您需要登录后才可以回帖 登录 | 加入我们