一、问题引出
1.为什么使用Lambda表达式
public static void main(String[] args) {
//开启一个新线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("新线程执行的代码:" + Thread.currentThread().getName());
}
}
).start();
}
2.代码分析
public static void main(String[] args) {
//开启一个新线程
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("新线程执行的代码:" + Thread.currentThread().getName());
}
}
).start();
}
2.代码分析
1.Thread类需要一个Runable接口作为参数,其中的抽象方法Run()方法是用来指定线程任务的核心
2.为了指定Run方法体,不得不需要Runable的实现类
3.为了省去定义一个Runable的实现类,不得不使用匿名内部类
4.必须覆盖重写run方法,所有的方法名称,方法参数,方法返回值不得不重写一遍,而且不能出错
5.然而实际上我们只在乎方法体的实现
二、Lambda表达式初体验
public static void main(String[] args) {
new Thread(() -> {
System.out.println("Lambda线程:" + Thread.currentThread().getName());
}
).start();
}
Lambda表达式是一个匿名函数,可以理解为一段可以传递的代码。
Lambda表达式的优点:简化了匿名内部类的使用,语法更加简单。
在编程中,lambda 表达式(或者函数)只是一个匿名函数, 即一个没有名称也没有标识符的函数。它们都被写在你需要使用的地方,通常作为其他函数的参数。
Lambda表达式的基本语法:
either
(parameters) -> expression
or
(parameters) -> { statements; }
or
() -> expression
一个典型的 lambda 表达式如下所示:
(x, y) -> x + y //这个函数接受两个参数并返回它们的和。
请注意根据 x 和 y 的类型,方法可能会在多个地方使用。参数可以匹配到 int 类型整数或者字符串类型。 根据上下文,它将两个整数相加或者两个字符串拼接。
三、编写 Lambda 表达式的规则
- lambda表达式可以有零个、一个或多个参数
- 可以显式声明参数的类型,也可以从上下文推断参数的类型
- 多个参数必须包含在括号中,并用逗号分隔,空括号用于表示零个参数
- 当只有一个参数时,如果推断它的类型,可以不使用括号。如 a -> return a * a
- lambda表达式的函数体可以包含零个,一个或多个语句。
- 如果lambda表达式的函数体只有一行,则可以不用大括号,匿名函数的返回类型与函数体表达式的返回类型相同。当函数体中大于一行代码则需要用大括号包含。
无参demo
public interface UserService {
void goShow();
}
public class Demo03Lambda {
public static void main(String[] args) {
//传统写法
goShow(new UserService() {
@Override
public void goShow() {
System.out.println("show方法执行了。。。");
}
});
System.out.println("-------------------华丽的分割线-------------------------");
//lambda写法
goShow(() -> System.out.println("lambda show方法执行了"));
}
public static void goShow(UserService userService){
userService.goShow();
}
}
有参demo
public class Person {
private String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(Integer age) {
this.age = age;
}
public String getName() {
return name;
}
public Integer getAge() {
return age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
public class Demo04Lambda {
public static void main(String[] args) {
List list = new ArrayList<>();
list.add(new Person("刘德华",28));
list.add(new Person("郭富城",22));
list.add(new Person("古天乐",36));
//传统写法
Collections.sort(list, new Comparator() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge()-o2.getAge();
}
});
for (Person person:list){
System.out.println(person.toString());
}
System.out.println("--------------我是分割线------------------");
//lambda写法
Collections.sort(list,
(Person o1,Person o2) -> {return o1.getAge()-o2.getAge();
});
for (Person person:list){
System.out.println(person.toString());
}
}
}
四、Lambda表达式原理
1.首先看匿名内部类的本质是在编译时生成一个****$1.class文件
public class Demo01Lambda {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("新线程执行的代码:" + Thread.currentThread().getName());
}
}
).start();
}
}
编译后:
反编译匿名内部类:
public class Demo01Lambda
{
public static void main(String[] args)
{
new Thread(new Runnable()
{
public void run()
{
System.out.println("新线程执行的代码:" + Thread.currentThread().getName());
}
}).start();
System.out.println("主线程:" + Thread.currentThread().getName());
}
}
final class Demo01Lambda$1
implements Runnable
{
public void run()
{
System.out.println("新线程执行的代码:" + Thread.currentThread().getName());
}
}
2.lambda表达式原理
demo:
public class Demo03Lambda {
public static void main(String[] args) {
goShow(
() -> System.out.println("lambda show方法执行了"));
}
public static void goShow(UserService userService){
userService.goShow();
}
}
利用反编译工具查看.class发现无法反编译
再利用jdk自带的反汇编工具javap查看:
.class文件目录下执行命令:
javap -c -p ***.class
-c 反汇编
-p 显示所有类和方法
D:softwareideaSpaceJDK8-Studytargetclassescomjdklambda>javap -c -p Demo03Lambda.class
Compiled from "Demo03Lambda.java"
public class com.jdk.lambda.Demo03Lambda {
public com.jdk.lambda.Demo03Lambda();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: return
public static void main(java.lang.String[]);
Code:
0: invokedynamic #2, 0 // InvokeDynamic #0:goShow:()Lcom/jdk/lambda/UserService;
5: invokestatic #3 // Method goShow:(Lcom/jdk/lambda/UserService;)V
8: return
public static void goShow(com.jdk.lambda.UserService);
Code:
0: aload_0
1: invokeinterface #4, 1 // InterfaceMethod com/jdk/lambda/UserService.goShow:()V
6: return
private static void lambda$main$1();
Code:
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;)V
8: return
}
在反编译源码中看到,有一个静态方法lambda$main$1();然后通过debug方式可以查看到:
上面效果可以理解如下:
public class Demo03Lambda {
public static void main(String[] args) {
lambda$main$1();
}
private static void lambda$main$1(){
System.out.println("lambda show方法执行了");
}
}
为了更加直观的理解,我们可以在运行的时候添加 -Djdk.internal.lambda.dumpProxyClasses ,加上这个参数会将内部class码输出到文件中,可以在通过反编译工具查看.class文件
java -Djdk.internal.lambda.dumpProxyClasses 要运行的包名.方法名 //例如 java -Djdk.internal.lambda.dumpProxyClasses com.jdk.lambda.Demo03Lambda
小结:
匿名内部类在编译时会产生一个class文件
Lambda表达式在程序运行时会形成一个类
1.在类中新增了一个方法,这个方法的方法体就是Lambda表达式中的代码
2.还会形成你个匿名内部类,实现接口,重写抽象方法
3.在接口中重写方法会调用新生成的方法
五、Lambda表达式省略写法
在lambda表达式标准写法基础上,可以使用省略写法规则:
1.小括号内的参数类型可以省略
2.如果小括号内有且仅有一个参数,小括号可以省略
3.如果大括号内有且仅有一条语句,可以同时省略大括号,return语句和分号。
demo:
public interface StudentService {
void show(String name,Integer age);
}
public interface OrderService {
Integer show(String name);
}
public class Demo05Lambda {
public static void main(String[] args) {
//多参数,标准写法
goStudent((String name,Integer age) -> {
System.out.println("goStudent1:" + name+age+" 666...");
}
);
//多参数,省略参数类型写法
goStudent((name,age) -> {
System.out.println("goStudent2:" + name+age+" 666...");
}
);
//多参数,省略参数类型和大括号写法
goStudent((name,age) -> System.out.println("goStudent3:" + name+age+" 666...")
);
//单参数标准写法
goOrder((String name) -> {
System.out.println("goOrder1:" + name);
return 666;
});
//单参数省略参数类型写法
goOrder((name) -> {
System.out.println("goOrder2:" + name);
return 666;
});
//单参数省略参数类型和小括号写法
goOrder(name -> {
System.out.println("goOrder3:" + name);
return 666;
});
//单参数,大括号只有仅有一句语句,省略参数类型,小括号,大括号,return和分号写法
goOrder(name -> 666
);
}
public static void goStudent(StudentService studentService){
studentService.show("张三",22);
}
public static void goOrder(OrderService orderService){
orderService.show("李四");
}
}
六、Lambda表达式总结
Lambda表达式语法简洁,但并不是可以随便使用,有几个条件要注意:
1.方法的参数或局部变量类型必须为接口才能使用Lambda
2.接口中有且仅有一个抽象方法(@FunctionInterface注解标注的接口)
Lambda和匿名内部类的比较:
1.所需类型不一样
1)匿名内部类的类型可以是类,抽象类,接口
2)Lambda表达式需要的类型必须是接口
2.抽象方法的数量不一样
1)匿名内部类所需的接口中的抽象方法的数量是人任意的
2)Lambda表达式所需的接口中的抽象方法只能由一个
3.实现原理不一样
1)匿名内部类是在编译后生成一个.class文件
2)Lambda表达式实在程序运行时动态生成.class文件



