java1.8 拉姆达表达式_Java1.8之Lambda表达式

最新推荐文章于 2023-06-17 17:03:32 发布

薄荷味的长颈鹿

最新推荐文章于 2023-06-17 17:03:32 发布

阅读量425

点赞数

文章标签： java1.8 拉姆达表达式

本文链接：https://blog.csdn.net/weixin_33621280/article/details/114590330

版权

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

1 package com.demo.main;2

3 public classLambdaMain {4

5 public static voidmain(String[] args) {6

7 //1、创建一个匿名内部类

8 Addition addition = newAddition() {9

10 @Override11 public int add(int a, intb) {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 interfaceAddition {42

43 /**44 * 加法的方法45 *46 * @param a47 * @param b48 * @return49 */

50 int add(int a, intb);51 }52

53 }

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

1 一般函数结构类似，如下所示：2 int add(int a, intb){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 classLambdaMain {4

5 public static voidmain(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 returna;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 * @author48 *49 */

50 interfaceMethodNoReturnNoParam {51

52 voidlambda1();53 }54

55 /**56 * 2、单个参数无返回值57 *58 * @author59 *60 */

61 interfaceMethodNoReturnOneParam {62

63 void lambda2(inta);64 }65

66 /**67 * 3、两个参数无返回值68 *69 * @author70 *71 */

72 interfaceMethodNoReturnTwoParam {73

74 void lambda3(int a, intb);75 }76

77 /**78 * 4、无参数有返回值79 *80 * @author81 *82 */

83 interfaceMethodReturnNoParam {84

85 intlambda4();86 }87

88 /**89 * 5、一个参数有返回值90 *91 * @author92 *93 */

94 interfaceMethodReturnOneParam {95

96 int lambda5(inta);97 }98

99 /**100 * 6、两个参数有返回值101 *102 * @author103 *104 */

105 interfaceMethodReturnTwoParam {106

107 int lambda6(int a, intb);108 }109

110 }

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

1)、参数类型可以省略。

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

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

4)、如果方法体中唯一的语句是return返回语句，那省略大括号的同时return关键词也要省略掉。

1 package com.demo.main;2

3 public classLambdaMain {4

5 public static voidmain(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 * @author36 *37 */

38 interfaceMethodNoReturnNoParam {39

40 voidlambda1();41 }42

43 /**44 * 2、单个参数无返回值45 *46 * @author47 *48 */

49 interfaceMethodNoReturnOneParam {50

51 void lambda2(inta);52 }53

54 /**55 * 3、两个参数无返回值56 *57 * @author58 *59 */

60 interfaceMethodNoReturnTwoParam {61

62 void lambda3(int a, intb);63 }64

65 /**66 * 4、无参数有返回值67 *68 * @author69 *70 */

71 interfaceMethodReturnNoParam {72

73 intlambda4();74 }75

76 /**77 * 5、一个参数有返回值78 *79 * @author80 *81 */

82 interfaceMethodReturnOneParam {83

84 int lambda5(inta);85 }86

87 /**88 * 6、两个参数有返回值89 *90 * @author91 *92 */

93 interfaceMethodReturnTwoParam {94

95 int lambda6(int a, intb);96 }97

98 }

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

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

1 package com.demo.main;2

3 public classLambdaMain {4

5 public static voidmain(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

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 a31 * @return32 */

33 public int add(inta) {34 return a + 10;35 }36

37 /**38 * 静态方法引用39 *40 * @param a41 * @return42 */

43 public static int addStatic(inta) {44 return a + 10;45 }46

47 /**48 * 5、一个参数有返回值49 *50 * @author51 *52 */

53 interfaceMethodReturnOneParam {54

55 int lambda5(inta);56 }57

58 }

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

语法规则：类名::new。

1 package com.demo.po;2

3 public classDog {4

5 privateString name;6 private intage;7

8 publicString getName() {9 returnname;10 }11

12 public voidsetName(String name) {13 this.name =name;14 }15

16 public intgetAge() {17 returnage;18 }19

20 public void setAge(intage) {21 this.age =age;22 }23

24 @Override25 publicString toString() {26 return "Dog [name=" + name + ", age=" + age + "]";27 }28

29 public Dog(String name, intage) {30 System.out.println("含参构造函数！");31 this.name =name;32 this.age =age;33 }34

35 publicDog() {36 System.out.println("无参构造函数！");37 }38

39 }

1 package com.demo.main;2

3 import com.demo.po.Dog;4

5 public classLambdaMain {6

7 public static voidmain(String[] args) {8 //1、使用lambda表达式的方式使用

9 DogService dogService1_0 = () ->{10 return newDog();11 };12 dogService1_0.getDog();13

14 //2、简化方式

15 DogService dogService1_1 = () -> newDog();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 interfaceDogService {29

30 /**31 * 获取到一只无名狗32 *33 * @return34 */

35 Dog getDog();36 }37

38 interfaceDogService2 {39

40 /**41 * 获取到一个有名称的狗42 *43 * @param name44 * @param age45 * @return46 */

47 Dog getDog(String name, intage);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 classLambdaMain {9

10 public static voidmain(String[] args) {11 List list = new ArrayList();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 classLambdaMain {4

5 public static voidmain(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 biexiansheng16 *17 */

18 @FunctionalInterface19 interfaceFunctionInterface {20

21 /**22 * 抽象方法23 */

24 public void add(inta);25

26 /**27 * java.lang.Object中的public方法28 *29 * @param var30 * @return31 */

32 public boolean equals(Object var);33

34 //默认的方法

35 public default voiddefaultMethod() {36 System.out.println("默认的方法！！！");37 }38

39 //静态方法

40 public static voidstaticMethod() {41 System.out.println("静态的方法！！！");42 }43

44 }45

46 }