【JDK8新特性】之Lambda表达式
目录
- Lambda表达式
- 1. 需求分析
- 2.Lambda表达式初体验
- 3. Lambda的语法规则
- 3.1 Lambda练习1
- 3.2 Lambda练习2
- 4. @FunctionalInterface注解
- 5. Lambda表达式的原理
- 6.Lambda表达式的省略写法
- 7.Lambda表达式的使用前提
- 8.Lambda和匿名内部类的对比
Lambda表达式
Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
1. 需求分析
创建一个新的线程,指定线程要执行的任务
public static void main(String[] args) {// 开启一个新的线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println("新线程中执行的代码 : "+Thread.currentThread().getName());}}).start();System.out.println("主线程中的代码:" + Thread.currentThread().getName());}
代码分析:
- Thread类需要一个Runnable接口作为参数,其中的抽象方法run方法是用来指定线程任务内容的核心
- 为了指定run方法体,不得不需要Runnable的实现类
- 为了省去定义一个Runnable 的实现类,不得不使用匿名内部类
- 必须覆盖重写抽象的run方法,所有的方法名称,方法参数,方法返回值不得不都重写一遍,而且不能出错,
- 而实际上,我们只在乎方法体中的代码
2.Lambda表达式初体验
Lambda表达式是一个匿名函数,可以理解为一段可以传递的代码
new Thread(() -> { System.out.println("新线程Lambda表达式..." +Thread.currentThread().getName()); }).start();
Lambda表达式的优点:简化了匿名内部类的使用,语法更加简单。
匿名内部类语法冗余,体验了Lambda表达式后,发现Lambda表达式是简化匿名内部类的一种方式。
3. Lambda的语法规则
Lambda省去了面向对象的条条框框,Lambda的标准格式由3个部分组成:
(参数类型 参数名称) -> {代码体;
}
格式说明:
- (参数类型 参数名称):参数列表
- {代码体;} :方法体
- -> : 箭头,分割参数列表和方法体
3.1 Lambda练习1
练习无参无返回值的Lambda
定义一个接口
public interface UserService {void show();
}
然后创建主方法使用
public class Demo03Lambda {public static void main(String[] args) {goShow(new UserService() {@Overridepublic void show() {System.out.println("show 方法执行了...");}});System.out.println("----------");goShow(() -> { System.out.println("Lambda show 方法执行了..."); });}public static void goShow(UserService userService){userService.show();}
}
输出:
show 方法执行了...
----------
Lambda show 方法执行了...
3.2 Lambda练习2
完成一个有参且有返回值得Lambda表达式案例
创建一个Person对象
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {private String name;private Integer age;private Integer height;}
然后我们在List集合中保存多个Person对象,然后对这些对象做根据age排序操作
public static void main(String[] args) {List<Person> list = new ArrayList<>();list.add(new Person("周杰伦",33,175));list.add(new Person("刘德华",43,185));list.add(new Person("周星驰",38,177));list.add(new Person("郭富城",23,170));Collections.sort(list, new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {return o1.getAge()-o2.getAge();}});for (Person person : list) {System.out.println(person);}}
我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类,且执行的方法有参数和返回值,那么我们可以改写为Lambda表达式
public static void main(String[] args) {List<Person> list = new ArrayList<>();list.add(new Person("周杰伦",33,175));list.add(new Person("刘德华",43,185));list.add(new Person("周星驰",38,177));list.add(new Person("郭富城",23,170));/*Collections.sort(list, new Comparator<Person>() {@Overridepublic int compare(Person o1, Person o2) {return o1.getAge()-o2.getAge();}});for (Person person : list) {System.out.println(person);}*/System.out.println("------");Collections.sort(list,(Person o1,Person o2) -> {return o1.getAge() - o2.getAge();});for (Person person : list) {System.out.println(person);}}
输出结果
Person(name=郭富城, age=23, height=170)
Person(name=周杰伦, age=33, height=175)
Person(name=周星驰, age=38, height=177)
Person(name=刘德华, age=43, height=185)
4. @FunctionalInterface注解
@FunctionalInterface是JDK8中新增加的一个函数式注解,表示该注解修饰的接口只能有一个抽象方法。
/*** @FunctionalInterface* 这是一个函数式注解,被该注解修饰的接口只能声明一个抽象方法*/
@FunctionalInterface
public interface UserService {void show();}
5. Lambda表达式的原理
匿名内部类的本质是在编译时生成一个Class 文件。XXXXX
public class Demo01Lambda {public static void main(String[] args) {// 开启一个新的线程new Thread(new Runnable() {@Overridepublic void run() {System.out.println("新线程中执行的代码 :
"+Thread.currentThread().getName());}}).start();System.out.println("主线程中的代码:" + Thread.currentThread().getName());System.out.println("---------------");/*new Thread(() -> { System.out.println("新线程Lambda表达式..."
+Thread.currentThread().getName()); }).start();*/}
}
还可以通过反编译工具来查看生成的代码 XJad 工具来查看
static class Demo01Lambda$1
implements Runnable
{public void run()
{System.out.println((new StringBuilder()).append("新线程中执行的代码 : "
).append(Thread.currentThread().getName()).toString());}Demo01Lambda$1(){}
}
那么Lambda表达式的原理是什么呢?我们也通过反编译工具来查看
写的有Lambda表达式的class文件,我们通过XJad查看报错。这时我们可以通过JDK自带的一个工具:
javap 对字节码进行反汇编操作。
javap -c -p 文件名.class
-c:表示对代码进行反汇编
-p:显示所有的类和成员
反汇编的结果:
E:\workspace\OpenClassWorkSpace\JDK8Demo\target\classes\com\bobo\jdk\lambda>javap
-c -p Demo03Lambda.class
Compiled from "Demo03Lambda.java"
public class com.bobo.jdk.lambda.Demo03Lambda {public com.bobo.jdk.lambda.Demo03Lambda();Code:0: aload_01: invokespecial #1 // Method java/lang/Object."<init>":
()V4: return
public static void main(java.lang.String[]);Code:0: invokedynamic #2, 0 // InvokeDynamic #0:show:
()Lcom/bobo/jdk/lambda/service/UserService;5: invokestatic #3 // Method goShow:
(Lcom/bobo/jdk/lambda/service/UserService;)V8: return
public static void goShow(com.bobo.jdk.lambda.service.UserService);Code:0: aload_01: invokeinterface #4, 1 // InterfaceMethod
com/bobo/jdk/lambda/service/UserService.show:()V6: return
private static void lambda$main$0();Code:
在这个反编译的源码中我们看到了一个静态方法 lambda$main$0(),这个方法里面做了什么事情呢?我
们通过debug的方式来查看下:
上面的效果可以理解为如下:
为了更加直观的理解这个内容,我们可以在运行的时候添加 -
Djdk.internal.lambda.dumpProxyClasses, 加上这个参数会将内部class码输出到一个文件中
命令执行0: getstatic #5 // Field
java/lang/System.out:Ljava/io/PrintStream;3: ldc #6 // String Lambda show 方法执行了...5: invokevirtual #7 // Method
java/io/PrintStream.println:(Ljava/lang/String;)V8: return
}
在这个反编译的源码中我们看到了一个静态方法 lambda$main$0(),这个方法里面做了什么事情呢?我
们通过debug的方式来查看下:
上面的效果可以理解为如下:
public class Demo03Lambda {public static void main(String[] args) {....}private static void lambda$main$0();System.out.println("Lambda show 方法执行了...");}
}
为了更加直观的理解这个内容,我们可以在运行的时候添加 -
Djdk.internal.lambda.dumpProxyClasses, 加上这个参数会将内部class码输出到一个文件中
java -Djdk.internal.lambda.dumpProxyClasses 要运行的包名.类名
命令执行
E:\workspace\OpenClassWorkSpace\JDK8Demo\target\classes>java -
Djdk.internal.lambda.dumpProxyClasses com.bobo.jdk.lambda.Demo03Lambda
Lambda show 方法执行了...
可以看到这个匿名的内部类实现了UserService接口,并重写了show()方法。在show方法中调用了
Demo03Lambda.lambda$main$0(),也就是调用了Lambda中的内容。
public class Demo03Lambda {public static void main(String[] args) {goShow(new UserService() {@Overridepublic void show() {Demo03Lambda.lambda$main$0();}});System.out.println("----------");}public static void goShow(UserService userService){userService.show();}private static void lambda$main$0();System.out.println("Lambda show 方法执行了...");}
}
小结:
匿名内部类在编译的时候会产生一个class文件。
Lambda表达式在程序运行的时候会形成一个类。
- 在类中新增了一个方法,这个方法的方法体就是Lambda表达式中的代码
- 还会形成一个匿名内部类,实现接口,重写抽象方法
- 在接口中重写方法会调用新生成的方法
6.Lambda表达式的省略写法
在lambda表达式的标准写法基础上,可以使用省略写法的规则为:
- 小括号内的参数类型可以省略
- 如果小括号内有且仅有一个参数,则小括号可以省略
- 如果大括号内有且仅有一个语句,可以同时省略大括号,return 关键字及语句分号。
public class Demo05Lambda {public static void main(String[] args) {goStudent((String name,Integer age)->{return name+age+" 6666 ...";});// 省略写法goStudent((name,age)-> name+age+" 6666 ...");System.out.println("------");goOrder((String name)->{System.out.println("--->" + name);return 666;});// 省略写法goOrder(name -> {System.out.println("--->" + name);return 666;});goOrder(name -> 666);}public static void goStudent(StudentService studentService){studentService.show("张三",22);}public static void goOrder(OrderService orderService){orderService.show("李四");}}
7.Lambda表达式的使用前提
Lambda表达式的语法是非常简洁的,但是Lambda表达式不是随便使用的,使用时有几个条件要特别注意
- 方法的参数或局部变量类型必须为接口才能使用Lambda
- 接口中有且仅有一个抽象方法(@FunctionalInterface)
8.Lambda和匿名内部类的对比
匿名内部类简要分析
https://blog.csdn.net/qq_45696377/article/details/120492749
Lambda和匿名内部类的对比
- 所需类型不一样
- 匿名内部类的类型可以是 类,抽象类,接口
- Lambda表达式需要的类型必须是接口
- 抽象方法的数量不一样
- 匿名内部类所需的接口中的抽象方法的数量是随意的
- Lambda表达式所需的接口中只能有一个抽象方法
- 实现原理不一样
- 匿名内部类是在编译后形成一个class
- Lambda表达式是在程序运行的时候动态生成class
更多学习内容查看如下文章:
【Java全栈】Java全栈学习路线及项目全资料总结【JavaSE+Web基础+大前端进阶+SSM+微服务+Linux+JavaEE】
https://blog.csdn.net/qq_45696377/article/details/110575362
下一篇:
【JDK8新特性】之接口中新增的方法(默认方法和静态方法的作用)
https://blog.csdn.net/qq_45696377/article/details/120519387
【JDK8新特性】之Lambda表达式相关推荐
- JDK8新特性之Lambda表达式
转载自 JDK8新特性之Lambda表达式 什么是Lambda表达式 Java 8的一个大亮点是引入Lambda表达式,使用它设计的代码会更加简洁.当开发者在编写Lambda表达式时,也会随之被编译成 ...
- JDK8新特性:Lambda表达式、Stream流、日期时间工具类
重要特性: 可选类型声明:不需要声明参数类型,编译器可以统一识别参数值. 可选的参数圆括号:一个参数无需定义圆括号,但多个参数需要定义圆括号. 可选的大括号:如果主体包含了一个语句,就不需要大括号. ...
- JDK8新特性之Lambda表达式、函数式接口
JDK8特性之Lamdba.函数式接口 1. 什么是Lambda表达式 ❓ ⭐️1.1入门
- JDK8新特性之Lambda表达式和四大函数接口
在Java8中,加入了Lambda(Lambda expression),在使用它以前我们先聊聊为什么要加入Lamdba,使用它对于编程上有什么好处 一.Lamdba的作用 1.在我们需要把一些功能传 ...
- 熟悉JDK8新特性,“Lambda表达式与函数式接口”
Hello,你好呀,我是大白(●-●) 菜单 lambda表达式 函数式接口 lambda表达式 lambda表达式可以看成匿名内部类的一个简洁写法 在语法上,Lambda表达式包含三个部分: 参数列 ...
- jdk8新特性:Lambda表达式简单测试
import java.awt.event.ActionEvent; import java.awt.event.ActionListener;import javax.swing.JButton; ...
- java x=8_Java8新特性之lambda表达式
简介 Java8带来的新特性之一Lambda表达式,又称之为函数式编程,核心思想是将面向对象中的传递对象变为传递行为 语法 expression = (variable) -> anction ...
- java8新特性: lambda表达式:直接获得某个list/array/对象里面的字段集合
java8新特性: lambda表达式:直接获得某个list/array/对象里面的字段集合 比如,我有一张表: entity Category.java service CategoryServic ...
- 【java8新特性】——lambda表达式与函数式接口详解(一)
一.简介 java8于2014年发布,相比于java7,java8新增了非常多的特性,如lambda表达式.函数式接口.方法引用.默认方法.新工具(编译工具).Stream API.Date Time ...
- java8新特性之lambda表达式--超级详细版本
java8新特性之lambda表达式 1.什么是lambda表达式?为什么用它? 2. 为什么Java需要lambda表达式? 3. lambda表达式的语法 4.函数式接口 4.1 什么是函数式接口 ...
最新文章
- linux查看网卡物理编号_Linux下多网卡时,如何快速辨别网卡ID与物理网卡的对应关系(即ethtool命令)...
- Kotlin学习 PART 1:kotlin定义和目的
- Eclipse工作空间还原到最初状态
- 算法踩坑6-二叉搜索树排序
- 香港一小巴侧翻致1死16伤 警方:未见机件故障
- 10tb服务器硬盘 选购,2017最靠谱大容量机械硬盘选购指南(基于Backblaze硬盘寿命可靠性报告)...
- centos smb配置与win7共享
- CCNA-第十三篇-NAT-上
- 蚂蚁金服OceanBase挑战TPCC丨TPC-C基准测试之链路层优化
- 从Kaggle HuBMAP 比赛中学习语义分割
- 从化工技术员到微软最有价值专家(MVP)--我的IT从业路
- Chrome浏览器的自动保存密码提示功能禁用方法
- 匿名内部类为什么访问外部类局部变量必须是final的?
- 【算法】排序_堆排序
- TCP长连接和短连接的区别(好文章!)
- 「 C++ 通讯 」“Socket通信原理(TCP/IP)”研究
- 修改 Mixamo 导出的动画名字
- Markdown写出高大上时序图
- tomcat端口号修改
- dumpstate log总结