1. Lambda表达式
1.1 概念
- Lambda表达式: 特殊的匿名内部类，语法更加简洁 .是JDK1.8中的新特性.
- Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递.
1.2 需求
1、开启一个线程。并执行一个Runnable类型的任务。
public class Test01 {
public static void main(String[] args) {
//匿名内部类
Runnable tast1=new Runnable() {
public void run() {
System.out.println("这是使用匿名内部类"+Thread.currentThread().getName());
}
};
new Thread(tast1).start();
System.out.println("主线程的内容:"+Thread.currentThread().getName());
}
}
- Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
- 为了指定run方法体，不得不需要Runnable的实现类
- 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
- 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
- 而实际上，我们只在乎方法体中的代码.不会在意方法名.
1.3 lambda的语法
lambda表达式它由三部分组成
(数据类型 变量名,数据类型 变量名)->{方法体}
格式说明：
- (参数类型 参数名称):参数列表
- {代码体;} :方法体
- -> : 箭头，分割参数列表和方法体
1. 4Lambda练习
练习无参无返回值的Lambda
public class Test02 {
public static void goShow(UserService userService){
userService.show();
}
public static void main(String[] args) {
//1.自己创建一个UserService接口的实现类。并创建该类的对象。
UserService userService=new UserServiceImpl();
goShow(userService);
//2.使用匿名内部类
UserService userService1=new UserService() {
@Override
public void show() {
System.out.println("这是UserService的匿名实现类");
}
};
goShow(userService1);
//3.使用lambda表达式
UserService userService2=()->{
System.out.println("这是lambda表达式");
};
goShow(userService2);
}
}
interface UserService{
public void show();
}
class UserServiceImpl implements UserService{
@Override
public void show() {
System.out.println("这是UserService实现方法");
}
}
1.5 Lambda练习2
完成一个有参且有返回值得Lambda表达式案例.
创建一个People对象
@Data
@NoArgsConstructor
@AllArgsConstructor
class People{
private String name;
private int age;
}
测试:
public class Test03 {
public static void main(String[] args) {
List<People> list=new ArrayList<People>();
students.add(new Student("张三",34));
students.add(new Student("李四",45));
students.add(new Student("王五",25));
students.add(new Student("糖糖",35));
//按照年龄进行排序。第二个参数需要传递排序规则
// Comparator<People> comparator=new Comparator<People>() {
// public int compare(People o1, People o2) {
// return o1.getAge()-o2.getAge();
// }
// };
// Collections.sort(list,comparator);
// System.out.println(list);
System.out.println("=============================================");
Comparator<People> comparator1=(People o1,People o2)->{return o2.getAge()-o1.getAge();};
Collections.sort(list,comparator1);
System.out.println(list);
}
}
1.6 lambda表达式的缩写版
在lambda表达式的标准写法基础上，可以使用省略写法的规则为：
- 小括号内的参数类型可以省略
- 如果小括号内有且仅有一个参数，则小括号可以省略
- 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。
package com.ykq.jdk.lambda03;
public class Test03 {
public static void main(String[] args) {
// UserService userService=(String name,int age)->{return name+"~~~~~"+age;};
UserService userService=(name, age)-> name+"~~~~~"+age ;//可以省略lambda表达式参数的类型,以及{}和return 和分号；
goUserService(userService);
// StudentService studentService=(name)->{ System.out.println("我叫:"+name);};
// StudentService studentService= name->{ System.out.println("我叫:"+name);}; //int a=15;
goStudentService(name->{ System.out.println("我叫:"+name);});
}
public static void goStudentService(StudentService studentService){
studentService.print("李白");
}
public static void goUserService(UserService userService){//1.方法的参数必须是一个接口类型。 2.该接口有且只有一个抽象方法。
String s = userService.show("王力宏", 15);
System.out.println(s);
}
}
@FunctionalInterface
interface UserService{ //为了防止别人往该接口中添加新的抽象方法，可以使用一个注解FunctionInterface。
public String show(String name,int age);
default void fun(){};
}
interface StudentService{
public void print(String name);
}
1.7 lambda表达式使用的前提
Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意
- 方法的参数或局部变量类型必须为接口才能使用Lambda
- 接口中有且仅有一个抽象方法(@FunctionalInterface)
- 被@FunctionalInterface 修饰后该接口只能有一个抽象方法。
