Java1.8之Lambda表达式_jv当中lamada表达式本质是啥

1、Java8的lambda表达式，通过lambda表达式可以替代我们之前写的匿名内部类来实现接口。lambda表达式本质是一个匿名函数。

 1 package com.demo.main;
 2 
 3 public class LambdaMain {
 4 
 5     public static void main(String[] args) {
 6 
 7         // 1、创建一个匿名内部类
 8         Addition addition = new Addition() {
 9 
10             @Override
11             public int add(int a, int b) {
12 
13                 return a + b;
14             }
15 
16         };
17         // 传统的匿名内部类来实现接口。
18         System.out.println("调用匿名内部类来实现接口：" + addition.add(2, 3));
19 
20         // 2、Java8的lambda表达式，通过lambda表达式可以替代我们之前写的匿名内部类来实现接口。
21         // lambda表达式本质是一个匿名函数。
22         // 2.1、lambda由三部分组成，()是参数列表，->剪头符号，{}代表方法体。
23         Addition a2 = (int a, int b) -> {
24             return a + b;
25         };
26         System.out.println("lambda表达式a2：" + a2.add(3, 3));
27 
28         // 2.2、可以省略参数列表里面的参数类型
29         Addition a3 = (a, b) -> {
30             return a + b;
31         };
32         System.out.println("lambda表达式a3：" + a3.add(3, 3));
33 
34     }
35 
36     /**
37      * 
38      * @author 创建一个接口，定义一个方法
39      *
40      */
41     interface Addition {
42 
43         /**
44          * 加法的方法
45          * 
46          * @param a
47          * @param b
48          * @return
49          */
50         int add(int a, int b);
51     }
52 
53 }

 

2、Lambda表达式语法，形如(int a, int b) -> {return a + b;}，lambda本质就是一个（匿名）函数，匿名函数，就是没有方法名称的函数。

1 一般函数结构类似，如下所示：
2 int add(int a, int b){
3     return  a + b;
4 }
5 
6 一般函数的，结构如：返回值 方法名称(参数列表) 方法体。

 

3、而Lamdba表达式函数，只有参数列表和方法体。结构如：(参数列表) -> {方法体};

详细说明，如下所示：

　　1）、()括号用来描述参数列表。
　　2）、{}大括号用来描述方法体。
　　3）、->尖括号，Lambda运算符，可以叫做箭头符号，或者goes to。

 

4、Lambda表达式语法，关于接口方法参数、无参、单个参数、两个参数、有返回值、没有返回值的情况。如何来根据lambda来返回接口函数。

  1 package com.demo.main;
  2 
  3 public class LambdaMain {
  4 
  5     public static void main(String[] args) {
  6         // 1、无参数无返回值
  7         MethodNoReturnNoParam methodNoReturnNoParam = () -> {
  8             System.out.println("无参数无返回值");
  9         };
 10         methodNoReturnNoParam.lambda1();
 11 
 12         // 2、单个参数无返回值
 13         MethodNoReturnOneParam methodNoReturnOneParam = (int a) -> {
 14             System.out.println("单个参数无返回值,a = " + a);
 15         };
 16         methodNoReturnOneParam.lambda2(3);
 17 
 18         // 3、两个参数无返回值
 19         MethodNoReturnTwoParam methodNoReturnTwoParam = (int a, int b) -> {
 20             System.out.println("两个参数无返回值,a + b = " + (a + b));
 21         };
 22         methodNoReturnTwoParam.lambda3(3, 4);
 23 
 24         // 4、无参数有返回值
 25         MethodReturnNoParam methodReturnNoParam = () -> {
 26             return 8;
 27         };
 28         System.out.println("无参数有返回值:" + methodReturnNoParam.lambda4());
 29 
 30         // 5、一个参数有返回值
 31         MethodReturnOneParam methodReturnOneParam = (int a) -> {
 32             return a;
 33         };
 34         System.out.println("一个参数有返回值,a = " + methodReturnOneParam.lambda5(9));
 35 
 36         // 6、一个参数有返回值
 37         MethodReturnTwoParam methodReturnTwoParam = (int a, int b) -> {
 38             return a + b;
 39         };
 40         System.out.println("一个参数有返回值,a + b = " + methodReturnTwoParam.lambda6(9, 9));
 41 
 42     }
 43 
 44     /**
 45      * 1、无参数无返回值
 46      * 
 47      * @author
 48      *
 49      */
 50     interface MethodNoReturnNoParam {
 51 
 52         void lambda1();
 53     }
 54 
 55     /**
 56      * 2、单个参数无返回值
 57      * 
 58      * @author
 59      *
 60      */
 61     interface MethodNoReturnOneParam {
 62 
 63         void lambda2(int a);
 64     }
 65 
 66     /**
 67      * 3、两个参数无返回值
 68      * 
 69      * @author
 70      *
 71      */
 72     interface MethodNoReturnTwoParam {
 73 
 74         void lambda3(int a, int b);
 75     }
 76 
 77     /**
 78      * 4、无参数有返回值
 79      * 
 80      * @author
 81      *
 82      */
 83     interface MethodReturnNoParam {
 84 
 85         int lambda4();
 86     }
 87 
 88     /**
 89      * 5、一个参数有返回值
 90      * 
 91      * @author
 92      *
 93      */
 94     interface MethodReturnOneParam {
 95 
 96         int lambda5(int a);
 97     }
 98 
 99     /**
100      * 6、两个参数有返回值
101      * 
102      * @author
103      *
104      */
105     interface MethodReturnTwoParam {
106 
107         int lambda6(int a, int b);
108     }
109 
110 }

 

5、Lambda表达式语法，精简写法，如下所示：

　　1）、参数类型可以省略。
　　2）、假如只有一个参数，()括号可以省略。
　　3）、如果方法体只有一条语句，{}大括号可以省略。
　　4）、如果方法体中唯一的语句是return返回语句，那省略大括号的同时return关键词也要省略掉。

 1 package com.demo.main;
 2 
 3 public class LambdaMain {
 4 
 5     public static void main(String[] args) {
 6         // 1、无参数无返回值
 7         MethodNoReturnNoParam methodNoReturnNoParam = () -> System.out.println("无参数无返回值");
 8         methodNoReturnNoParam.lambda1();
 9 
10         // 2、单个参数无返回值
11         MethodNoReturnOneParam methodNoReturnOneParam = a -> System.out.println("单个参数无返回值,a = " + a);
12         methodNoReturnOneParam.lambda2(3);
13 
14         // 3、两个参数无返回值
15         MethodNoReturnTwoParam methodNoReturnTwoParam = (a, b) -> System.out.println("两个参数无返回值,a + b = " + (a + b));
16         methodNoReturnTwoParam.lambda3(3, 4);
17 
18         // 4、无参数有返回值
19         MethodReturnNoParam methodReturnNoParam = () -> 8;
20         System.out.println("无参数有返回值:" + methodReturnNoParam.lambda4());
21 
22         // 5、一个参数有返回值
23         MethodReturnOneParam methodReturnOneParam = a -> a + 10;
24         System.out.println("一个参数有返回值,a = " + methodReturnOneParam.lambda5(9));
25 
26         // 6、一个参数有返回值
27         MethodReturnTwoParam methodReturnTwoParam = (a, b) -> a + b;
28         System.out.println("一个参数有返回值,a + b = " + methodReturnTwoParam.lambda6(9, 9));
29 
30     }
31 
32     /**
33      * 1、无参数无返回值
34      * 
35      * @author
36      *
37      */
38     interface MethodNoReturnNoParam {
39 
40         void lambda1();
41     }
42 
43     /**
44      * 2、单个参数无返回值
45      * 
46      * @author
47      *
48      */
49     interface MethodNoReturnOneParam {
50 
51         void lambda2(int a);
52     }
53 
54     /**
55      * 3、两个参数无返回值
56      * 
57      * @author
58      *
59      */
60     interface MethodNoReturnTwoParam {
61 
62         void lambda3(int a, int b);
63     }
64 
65     /**
66      * 4、无参数有返回值
67      * 
68      * @author
69      *
70      */
71     interface MethodReturnNoParam {
72 
73         int lambda4();
74     }
75 
76     /**
77      * 5、一个参数有返回值
78      * 
79      * @author
80      *
81      */
82     interface MethodReturnOneParam {
83 
84         int lambda5(int a);
85     }
86 
87     /**
88      * 6、两个参数有返回值
89      * 
90      * @author
91      *
92      */
93     interface MethodReturnTwoParam {
94 
95         int lambda6(int a, int b);
96     }
97 
98 }

 

6、方法引用，如果多个lamdba表达式实现函数都是一样的话，可以封装成通用方法，以方便维护，此时可以使用方法引用实现。

　　语法规则：对象::方法。假如是static静态方法，可以直接类名::方法。

 1 package com.demo.main;
 2 
 3 public class LambdaMain {
 4 
 5     public static void main(String[] args) {
 6 //        // 创建对象
 7 //        LambdaMain lambdaMain = new LambdaMain();
 8 //        // 采用对象引用的方式进行实现
 9 //        MethodReturnOneParam methodReturnOneParam_1 = lambdaMain::add;
10 //        System.out.println(methodReturnOneParam_1.lambda5(10));
11 //
12 //        // 采用对象引用的方式进行实现
13 //        MethodReturnOneParam methodReturnOneParam_2 = lambdaMain::add;
14 //        System.out.println(methodReturnOneParam_2.lambda5(40));
15         
16         
17         // 创建对象
18         // 采用静态对象引用的方式进行实现
19         MethodReturnOneParam methodReturnOneParam_1 = LambdaMain::addStatic;
20         System.out.println(methodReturnOneParam_1.lambda5(10));
21 
22         // 采用静态对象引用的方式进行实现
23         MethodReturnOneParam methodReturnOneParam_2 = LambdaMain::addStatic;
24         System.out.println(methodReturnOneParam_2.lambda5(40));
25     }
26 
27     /**
28      * 方法引用，如果多个lamdba表达式实现函数都是一样的话，可以封装成通用方法，以方便维护，此时可以使用方法引用实现。
29      * 
30      * @param a
31      * @return
32      */
33     public int add(int a) {
34         return a + 10;
35     }
36 
37     /**
38      * 静态方法引用
39      * 
40      * @param a
41      * @return
42      */
43     public static int addStatic(int a) {
44         return a + 10;
45     }
46 
47     /**
48      * 5、一个参数有返回值
49      *
50      * @author
51      *
52      */
53     interface MethodReturnOneParam {
54 
55         int lambda5(int a);
56     }
57 
58 }

 

7、构造方法引用，如果函数式接口的实现切好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用。

语法规则：类名::new。

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

 

 1 package com.demo.main;
 2 
 3 import com.demo.po.Dog;
 4 
 5 public class LambdaMain {
 6 
 7     public static void main(String[] args) {
 8         // 1、使用lambda表达式的方式使用
 9         DogService dogService1_0 = () -> {
10             return new Dog();
11         };
12         dogService1_0.getDog();
13 
14         // 2、简化方式
15         DogService dogService1_1 = () -> new Dog();
16         dogService1_1.getDog();
17 
18         // 3、构造方法引用，如果函数式接口的实现切好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用。
19         DogService dogService1_2 = Dog::new;
20         dogService1_2.getDog();
21 
22         // 4、构造方法引用，有参构造函数调用
23         DogService2 dogService2_1 = Dog::new;
24         dogService2_1.getDog("小黄", 2);
25 
26     }
27 
28     interface DogService {
29 
30         /**
31          * 获取到一只无名狗
32          * 
33          * @return
34          */
35         Dog getDog();
36     }
37 
38     interface DogService2 {
39 
40         /**
41          * 获取到一个有名称的狗
42          * 
43          * @param name
44          * @param age
45          * @return
46          */
47         Dog getDog(String name, int age);
48     }
49 
50 }

 

8、集合使用lambda表达式对数据进行排序，遍历等操作。对于参数是接口函数的方法，需要传递lamdba表达式作为参数进行调用。

 1 package com.demo.main;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 import com.demo.po.Dog;
 7 
 8 public class LambdaMain {
 9 
10     public static void main(String[] args) {
11         List<Dog> list = new ArrayList<Dog>();
12         list.add(new Dog("小黄", 5));
13         list.add(new Dog("小花", 4));
14         list.add(new Dog("旺财", 3));
15         list.add(new Dog("团团", 2));
16         list.add(new Dog("圆圆", 1));
17 
18         // 排序
19         System.out.println("lambda集合排序!!!");
20         // sort的参数是接口函数，需要使用lambda表达式匿名函数形式
21         list.sort((dog1, dog2) -> dog1.getAge() - dog2.getAge());
22         System.out.println(list);
23         System.out.println();
24 
25         // 遍历集合
26         System.out.println("lamdba集合遍历：");
27         list.forEach(System.out::println);
28     }
29 
30 }

 

9、@FunctionalInterface注解，此注解是函数式接口注解，所谓的函数式接口，当然首先是一个接口，然后就是在这个接口里面只能有一个抽象方法。这种类型的接口也称为SAM接口，即Single Abstract Method interfaces。

特点：

　　1）、接口有且仅有一个抽象方法。
　　2）、运行定义静态方法。
　　3）、允许定义默认方法。
　　4）、允许java.lang.Object中的public方法。
　　5）、该注解不是必须的，如果一个接口符合"函数式接口"定义，那么加不加该注解都没有影响。加上该注解能够更好的让编译器进行检查。如果编写的不是函数时接口，但是加上该注解，那么编译器会报错。

 1 package com.demo.main;
 2 
 3 public class LambdaMain {
 4 
 5     public static void main(String[] args) {
 6         FunctionInterface functionInterface = (int a) -> {
 7             System.out.println("a = " + a);
 8         };
 9         functionInterface.add(10);
10     }
11 
12     /**
13      * 正确的函数式接口
14      * 
15      * @author biexiansheng
16      *
17      */
18     @FunctionalInterface
19     interface FunctionInterface {
20 
21         /**
22          * 抽象方法
23          */
24         public void add(int a);
25 
26         /**
27          * java.lang.Object中的public方法
28          * 
29          * @param var
30          * @return
31          */
32         public boolean equals(Object var);
33 
34         // 默认的方法
35         public default void defaultMethod() {
36             System.out.println("默认的方法！！！");
37         }
38 
39         // 静态方法
40         public static void staticMethod() {
41             System.out.println("静态的方法！！！");
42         }
43 
44     }
45 
46 }

 

10、系统内置函数式接口，Java8的推出，是以lamdba重要特性，一起推出的，其中系统内置了一系列函数式接口。在jdk的java.util.function包下，有一系列的内置函数式接口：

 1 package com.demo.main;
 2 
 3 import java.util.function.IntConsumer;
 4 import java.util.function.IntFunction;
 5 import java.util.function.IntPredicate;
 6 
 7 public class LambdaMain {
 8 
 9     public static void main(String[] args) {
10         // 在jdk的java.util.function包下，有一系列的内置函数式接口
11         // 1、使用int函数接口
12         IntFunction<Integer> intFunction = (a) -> {
13             return a + 10;
14         };
15         System.out.println(intFunction.apply(20));
16         
17         // 2、使用int判断函数接口
18         final int aa = 20;
19         IntPredicate intPredicate = (a) -> {
20             return a == aa;
21         };
22         System.out.println(intPredicate.test(aa));
23         
24         // 3、使用int传递参数的形式
25         IntConsumer intConsumer = (a) -> {
26             System.out.println("a = " + a);
27         };
28         intConsumer.accept(20);
29         
30         // 书写技巧：首先定义一个接口函数对象，然后后面跟lambda表达式。
31         // lambda参数列表根据接口函数的方法参数类型和参数个数。
32         // lambda的方法体，是否有返回值，根据接口函数的方法是否有返回值。
33     }
34 
35 }