JDK新特性-Lambda表达式的神操作

也想出现在这里？点击联系我~

一、Lambda表达式的介绍

• Lambda表达式是 Java8 中最重要的新功能之一。使用 Lambda 表达式可以替代只有一个抽象函数的接口实现，告别匿名内部类，代码看起来更简洁易懂。Lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作。
• lambda表达式可以替代只有一个抽象函数的接口实现，告别匿名内部类，代码看起来更简洁易懂
• lambda表达式同时还提升了对集合、框架的迭代、遍历、过滤数据的操作
• lambda可以极大的减少代码冗余，同时代码的可读性要好过冗长的内部类，匿名类

例如以前我们使用匿名内部类来实现代码：

1. Runnablerunnable=newRunnable(){
2. @Override
3. publicvoidrun(){
4. System.out.println("running1…..");
5. }
6. };
7. runnable.run();

使用lambda表达式实现更简洁的代码：

1. Runnablerunnable3=()->System.out.println("running2….");
2. runnable3.run();

lambda表达式语法：

1. LambdaParameters->LambdaBody

在这里插入图片描述

args -> expr或者(object … args)-> {函数式接口抽象方法实现逻辑}

1、()参数的个数，根据函数式接口里面抽象的参数个数来决定，当参数只有一个的时候，()可以省略

2、当expr逻辑非常简单的时候，{}和return可以省略

案例说明：

1. publicstaticvoidmain(String[]args)throwsException{
2. Callable<String>c1=newCallable(){
3. @Override
4. publicStringcall()throwsException{
5. return"muxiaonong";
6. }
7. };
8. System.out.println(c1.call());
10. Callable<String>c2=()->{return"muxiaonong2";};
11. System.out.println(c2.call());
13. //逻辑很简单的时候省略{}和return
14. Callable<String>c3=()->"muxiaonong3";
15. System.out.println(c3.call());
16. }

二、Lambda表达式的特点

• 函数式编程
• 参数类型自动推断
• 代码量少，简洁

三、Lambda表达式案例

实现方式列表：

1. ()->{}
2. ()->{System.out.println(1);}
3. ()->System.out.println(1)
4. ()->{return100;}
5. ()->100
6. ()->null
7. (intx)->{returnx+1;}
8. (intx)->x+1
9. (x)->x+1
10. x->x+1

案例1：线程实现方式：

1. publicstaticvoidmain(String[]args){
2. //匿名内部类方式
3. newThread(newRunnable(){
4. @Override
5. publicvoidrun(){
6. System.out.println("runing1……….");
7. }
8. });
10. //Lambda表达式方式
11. newThread(()->{System.out.println("runing2…..");}).start();
12. }

案例2：集合遍历实现方式

1. publicstaticvoidmain(String[]args){
2. List<String>list=Arrays.asList("java","python","scala","javascript");
4. //普通匿名内部类方式
5. Collections.sort(list,newComparator<String>(){
6. @Override
7. publicintcompare(Stringo1,Stringo2){
8. returno1.length()-o2.length();
9. }
10. });
12. //Lambda方式
13. Collections.sort(list,(a,b)->a.length()-b.length());
14. list.forEach(System.out::println);
15. }

四、Lambda表达式的应用场景

重要的事情说三遍：任何有函数式接口的地方 * 3

什么是函数式接口： 只有一个抽象方法(Object类中的方法除外)的接口是函数式接口

五、Lambda表达式实际应用

5.1 无参实体类模拟

模拟数据库连接层：

1. @FunctionalInterface
2. publicinterfaceStudentDao{
3. voidinsert(Studentstudent);
4. }

实体类

1. /**@Authormxn
2. *@Description学生实体类
3. *@Date10:192020/11/7
4. *@Param
5. *@return
6. **/
7. publicclassStudent{
8. }
9. publicstaticvoidmain(String[]args){
10. StudentDaosd1=newStudentDao(){
11. @Override
12. publicvoidinsert(Studentstudent){
13. System.out.println("插入学生1");
14. }
15. };
17. StudentDaosd2=(student)->{
18. System.out.println("student:"+student);
19. };
21. StudentDaosd3=(Studentstudent)->System.out.println("student3:"+student);
23. sd1.insert(newStudent());//输出插入学生1
24. sd2.insert(newStudent());//输出
25. sd3.insert(newStudent());//输出
26. }

5.2 有参实体类模拟

实体类

1. /**@Authormxn
2. *@Description
3. *@Date10:262020/11/7
4. *@Param
5. *@return
6. **/
7. publicclassTeacher{
8. }

接口模拟层

1. @FunctionalInterface
2. publicinterfaceTeacherDao{
3. intget(Teacherteacher);
4. }

实现层

1. publicstaticvoidmain(String[]args){
2. TeacherDaotd1=newTeacherDao(){
3. @Override
4. publicintget(Teacherteacher){
5. return1;
6. }
7. };
8. TeacherDaotd2=(teacher)->{return2;};
9. TeacherDaotd3=(Teacherteacher)->{return3;};
10. TeacherDaotd4=(teacher)->4;
11. TeacherDaotd5=(Teacherteacher)->5;
13. System.out.println(td1.get(newTeacher()));//输出1
14. System.out.println(td2.get(newTeacher()));//输出2
15. System.out.println(td3.get(newTeacher()));//输出3
16. System.out.println(td4.get(newTeacher()));//输出4
17. System.out.println(td5.get(newTeacher()));//输出5
18. }

六、函数式接口

Supplier：代表一个输出

Consumer：代表一个输入

BiConsumer：代表两个输入

Function：代表一个输入，一个输出(一般输入和输出是不同类型的)

UnaryOperator：代表一个输入，一个输出(输入和输出是相同类型的)

BiFunction：代表两个输入，一个输出(一般输入和输出是不同类型的)

BinaryOperator：代表两个输入，一个输出(输入和输出是相同类型的)

在Java中提供了一系列的函数式接口，用来接受后续传入的逻辑，但是对输入和输出有要求

6.1 Supplier：代表一个输出

1. Supplier<String>s1=()->{return"muxiaonong";};
2. Supplier<String>s2=()->"muxiaonong2";
3. System.out.println(s1.get());//输出muxiaonong
4. System.out.println(s2.get());//输出muxiaonong2

6.2 Consumer：代表一个输入

1. Consumer<String>c11=(str)->System.out.println(str);
2. c11.accept("beijing");//输出beijing

6.3 BiConsumer：代表两个输入

1. BiFunction<String,String,Integer>bf=(a,b)->a.length()+b.length();
2. System.out.println(bf.apply("大吉大利","今晚吃鸡"));//输出一个字符串长度8

6.4 Function：代表一个输入，一个输出

1. //Function<String,Integer>用来接收后面的函数的实现，规定必须有一个输入(String)有一个输出(Integer)
2. Function<String,Integer>f1=(str)->{returnstr.length();};
3. System.out.println(f1.apply("abcdefg"));//输出长度7

七、方法的引用

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法，方法引用提供了一种引用而不执行方法的方式，如果抽象方法的实现恰好可以使用调用另外一个方法来实现，就有可能可以使用方法引用

7.1 方法引用的分类

7.2 静态方法引用

静态方法引用： 如果函数式接口的实现恰好可以通过 调用一个静态方法 来实现，那么就可以使用静态方法引用

1. /**
2. *@program:lambda
3. *@ClassNameTest2
4. *@description:
5. *@author:muxiaonong
6. *@create:2020-10-2822:15
7. *@Version1.0
8. **/
9. publicclassTest2{
10. //无参静态方法
11. staticStringput(){
12. System.out.println("put…..");
13. return"put";
14. }
16. //有参静态方法
17. publicstaticvoidgetSize(intsize){
18. System.out.println(size);
19. }
21. //有参有返回值静态方法
22. publicstaticStringtoUpperCase(Stringstr){
23. returnstr.toUpperCase();
24. }
26. //两个入参，一个返回值静态方法
27. publicstaticIntegergetLength(Stringstr,Stringstr2){
28. returnstr.length()+str2.length();
29. }
31. publicstaticvoidmain(String[]args){
32. //无参静态方法-普通调用
33. System.out.println(put());//输出put
34. //无参静态方法-原生调用
35. Supplier<String>s1=()->Test2.put();
36. System.out.println(s1.get());//输出put
37. //无参静态方法-静态方法引用
38. Supplier<String>s2=Test2::put;
39. System.out.println(s2.get());//输出put
40. //无参静态方法-内部类调用
41. Supplier<String>s3=Fun::hehe;
42. System.out.println(s3.get());//输出hehe
44. //有参静态方法-静态方法引用
45. Consumer<Integer>c1=Test2::getSize;
46. Consumer<Integer>c2=(size)->Test2.getSize(size);
47. c1.accept(123);
48. c2.accept(111);
50. //有参有返回值静态方法
51. Function<String,String>f1=(str)->str.toUpperCase();
52. Function<String,String>f2=(str)->Test2.toUpperCase(str);
53. Function<String,String>f3=Test2::toUpperCase;
54. Function<String,String>f4=Test2::toUpperCase;
56. System.out.println(f1.apply("abc"));//输出ABC
57. System.out.println(f2.apply("abc"));//输出ABC
58. System.out.println(f3.apply("abc"));//输出ABC
59. System.out.println(f4.apply("abc"));//输出ABC
61. //两个参数一个返回值函数式接口
62. BiFunction<String,String,Integer>bf=(a,b)->a.length()+b.length();
63. BiFunction<String,String,Integer>bf2=Test2::getLength;
64. System.out.println(bf2.apply("abc","def"));//输出6
65. System.out.println(bf.apply("abc","def"));//输出6
67. }
69. //内部类
70. classFun{
71. publicstaticStringhehe(){
72. return"hehe";
73. }
75. publicstaticStringtoUpperCase(Stringstr){
76. returnstr.toUpperCase();
77. }
79. }
81. }

7.3 实例方法引用

实例方法引用： 如果函数式接口的实现恰好可以通过调用一个实例的实例方法来实现，那么就可以使用实例方法引用

1. publicclassTest3{
2. //实例无参方法
3. publicStringput(){
4. return"put…";
5. }
7. //实例有参方法
8. publicvoidgetSize(intsize){
9. System.out.println("size:"+size);
10. }
12. //实例有参有返回值方法
13. publicStringtoUpperCase(Stringstr){
14. returnstr.toUpperCase();
15. }
16. publicstaticvoidmain(String[]args){
17. //实例无参方法返回-普通调用
18. System.out.println(newTest3().put());//输出put…
19. Supplier<String>s1=()->newTest3().put();
20. Supplier<String>s2=()->{returnnewTest3().put();};
21. Supplier<String>s3=newTest3()::put;
22. System.out.println(s1.get());//输出put…
23. System.out.println(s2.get());//输出put…
24. System.out.println(s3.get());//输出put…
26. //唯一的创建一个test3对象
27. Test3test=newTest3();
29. Consumer<Integer>c1=(size)->newTest3().getSize(size);
30. Consumer<Integer>c2=newTest3()::getSize;
31. Consumer<Integer>c3=test::getSize;
34. c1.accept(123);//输出size:123
35. c2.accept(123);//输出size:123
36. c3.accept(123);//输出size:123
38. Function<String,String>f1=(str)->str.toUpperCase();
39. Function<String,String>f2=(str)->test.toUpperCase(str);
40. Function<String,String>f3=newTest3()::toUpperCase;
41. Function<String,String>f4=test::toUpperCase;
42. System.out.println(f1.apply("abc"));//输出ABC
43. System.out.println(f2.apply("abc"));//输出ABC
44. System.out.println(f3.apply("abc"));//输出ABC
45. System.out.println(f4.apply("abc"));//输出ABC
46. }
47. }

7.4 对象方法引用

对象方法引用： 抽象方法的第一个参数类型刚好是实例方法的类型，抽象方法剩余的参数恰好可以当做实例方法的参数。如果函数式接口的实现能由上面说的实例方法调用来实现的话，那么就可以使用对象方法引用

1. /**@Authormxn
2. *@Description//TODO对象方法引用
3. *@Date14:262020/11/7
4. *@Param
5. *@return
6. **/
7. publicclassTest4{
8. publicstaticvoidmain(String[]args){
9. Consumer<Too>c1=(too)->newToo().foo();
10. c1.accept(newToo());//输出foo
12. Consumer<Too>c2=(Tootoo)->newToo2().foo();
13. c2.accept(newToo());//输出foo—too2
15. Consumer<Too>c3=Too::foo;
16. c3.accept(newToo());//输出foo
18. BiConsumer<Too2,String>bc=(too2,str)->newToo2().show(str);
19. BiConsumer<Too2,String>bc2=Too2::show;
20. bc.accept(newToo2(),"abc");
21. bc2.accept(newToo2(),"def");
23. BiFunction<Exec,String,Integer>bf1=(e,s)->newExec().test(s);
24. bf1.apply(newExec(),"abc");
25. BiFunction<Exec,String,Integer>bf2=Exec::test;
26. bf2.apply(newExec(),"def");
27. }
28. }
30. classExec{
31. publicinttest(Stringname){
32. return1;
33. }
35. }
37. classToo{
38. publicIntegerfun(Strings){
39. return1;
40. }
41. publicvoidfoo(){
42. System.out.println("foo");
43. }
44. }
45. classToo2{
46. publicIntegerfun(Strings){
47. return1;
48. }
49. publicvoidfoo(){
50. System.out.println("foo—too2");
51. }
53. publicvoidshow(Stringstr){
54. System.out.println("show—too2"+str);
55. }
56. }

7.5 构造方法引用

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

1. /**@Authormxn
2. *@Description//TODO构造方法引用
3. *@Date14:272020/11/7
4. *@Param
5. *@return
6. **/
7. publicclassTest5{
8. publicstaticvoidmain(String[]args){
9. Supplier<Person>s1=()->newPerson();
10. s1.get();//输出调用无参的构造方法
11. Supplier<Person>s2=Person::new;
12. s2.get();//输出调用无参的构造方法
14. Supplier<List>s3=ArrayList::new;
15. Supplier<Set>s4=HashSet::new;
16. Supplier<Thread>s5=Thread::new;
17. Supplier<String>s6=String::new;
19. Consumer<Integer>c1=(age)->newAccount(age);
20. Consumer<Integer>c2=Account::new;
21. c1.accept(123);//输出age参数构造123
22. c2.accept(456);//输出age参数构造456
24. Function<String,Account>f1=(str)->newAccount(str);
25. Function<String,Account>f2=Account::new;
26. f1.apply("abc");//输出str参数构造abc
27. f2.apply("def");//输出str参数构造def
29. }
30. }
32. classAccount{
33. publicAccount(){
34. System.out.println("调用无参构造方法");
35. }
37. publicAccount(intage){
38. System.out.println("age参数构造"+age);
39. }
41. publicAccount(Stringstr){
42. System.out.println("str参数构造"+str);
43. }
44. }
46. classPerson{
47. publicPerson(){
48. System.out.println("调用无参的构造方法");
49. }
50. }

八、小结

• Java8 引入 Lambda表达式是接收了函数式编程语言的思想，和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。引入 Lambda表达式是接收了函数式编程语言的思想，和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。引入 Lambda表达式是接收了函数式编程语言的思想，和指令式编程相比，函数式编程强调函数的计算比指令的执行重要。
• lambda表达式可以使代码看起来简洁，但一定程度上增加了代码的可读性以及调试的复杂性，所以在使用时应尽量是团队都熟悉使用，要么干脆就别用，不然维护起来是件较痛苦的事，今天的小知识就到这里了，有问题的小伙伴可以在下方进行留言，大家加油!

原文地址：https://mp.weixin.qq.com/s/9tWEoCqlEoHkKzAgMFAzzA