文章目录
一、Lamdba表达式的应用场景
1.函数式接口
函数式接口:一个有很多方法,但是有且只有一个抽象方法,其他的方法是(默认,静态,私有)的接口,这就是函数式接口
函数式接口的注解:
@FunctionalInterface注解
作用:可以检测接口是否是一个函数式接口
是:编译成功
否:编译失败(接口中没有抽象方法抽象方法的个数多余1个)
函数式接口的举例:
@FunctionalInterface
public interface MyFunctionalInterface {
//只定义一个抽象方法
public abstract void method();
}
函数式接口的作用:
只有确保接口中有且仅有一个抽象方法,Java中的Lambda才能顺利地进行推导。所以想要用Lambda表达式,则一定和函数式接口有关。
2.Lambda表达式的应用场景
- 函数式接口作为方法的参数
- 函数式接口作为方法的返回值
只有以上两种场景才能用Lambda表达式来替代。
1.如果方法的参数是一个函数式接口类型,那么就可以使用Lambda表达式进行替代。
原理如下:
因为方法的参数是一个接口,所以可以传递接口的实现类对象,
进而,我们也可以传递接口的匿名内部类
进而,我们还可以用Lambda表达式
(Lambda表达式都是参考着匿名内部类写出来的)
//函数式接口
@FunctionalInterface
public interface MyFunctionalInterface {
public abstract void method();
}
//函数式接口的实现类
class MyFunctionalInterfaceImpl implements MyFunctionalInterface{
@Override
public void method() {
System.out.println("函数式接口的实现类重写了里面的抽象方法");
}
}
public class Demo {
//定义一个方法,方法的参数使用函数式接口MyFunctionalInterface
public static void show(MyFunctionalInterface myInter){
myInter.method();
}
public static void main(String[] args) {
//调用show方法,show方法的参数是一个接口,所以可以传递接口的实现类对象
show(new MyFunctionalInterfaceImpl());
//调用show方法,方法的参数是一个接口,所以我们可以传递接口的匿名内部类
show(new MyFunctionalInterface() {
@Override
public void method() {
System.out.println("使用匿名内部类重写接口中的抽象方法");
}
});
//调用show方法,方法的参数是一个函数式接口,所以我们可以Lambda表达式
show(()->{
System.out.println("使用Lambda表达式重写接口中的抽象方法");
});
//简化Lambda表达式
show(()-> System.out.println("使用Lambda表达式重写接口中的抽象方法"));
}
}
因为方法的参数是一个接口,所以可以传递接口的实现类对象,
进而,我们也可以传递接口的匿名内部类
进而,我们还可以用Lambda表达式
2如果一个方法的返回值类型是一个函数式接口,那么就可以直接返回一个Lambda表达式。
原理如下:方法的返回值类型是一个函数式接口,所以你可以返回该接口的实现类对象;进而,你可以返回接口的匿名内部类;进而,你还可以返回Lambda表达式。(Lambda表达式都是参考着匿名内部类写出来的)
举例:
java.util.Comparator 接口是一个典型的函数式接口
public class Demo02Comparator {
//定义一个方法,方法的返回值类型使用函数式接口Comparator
public static Comparator<String> getComparator(){
//方法的返回值类型是一个接口,那么我们可以返回这个接口的匿名内部类
return new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.length()-o1.length();//按照字符串的降序排序
}
};
//方法的返回值是一个函数式接口,所以你可以返回一个Lambda表达式
return (String o1, String o2)->{
return o2.length()-o1.length();
};
//继续优化Lambda表达式
return (o1, o2)->o2.length()-o1.length();
}
public static void main(String[] args) {
String[] arr = {"aaa","b","cccccc","dddddddddddd"};
System.out.println(Arrays.toString(arr));//[aaa, b, cccccc, dddddddddddd]
Arrays.sort(arr,getComparator());
//输出排序后的数组
System.out.println(Arrays.toString(arr));//[dddddddddddd, cccccc, aaa, b]
}
}
3.怎么使用Lambda表达式?
- 先看看符不符合“函数式接口作为方法的参数” 或 “函数式接口作为方法的返回值” 这两者之一的条件
- 回想该函数式接口里面的唯一的抽象方法是什么,重点要看它有没有参数,有没有返回值
(抽象方法就是啥都没有写,所以你可以用lambda尽情地定义这个方法,但是这个方法有有没有参数,有没有返回值你得顾及上) - 无参 无返回值的无非就是
()->System.out.println()
无参 有返回值的无非就是()->{return "胡歌";}
(生产者Supplier,生产数据)
有参 无返回值的无非就是(String name)->{System.out.println(name);
(消费者Consumer,把参数消费掉,不返回东西)
有参 有返回值无非就是(String str)->{return str.length()>5;}
以上一个案例的代码为例,方法的返回值类型是一个函数式接口Comparator,那么你可以想一下该函数式接口Comparator里面的唯一一个抽象方法是什么?你想到它里面只有compare(String o1, String o2)这么一个抽象方法,该抽象方法有参数,然后用Lambda实现即可。
lambda表达式什么场景下用?
①提前准备一个函数式接口(接口+里面只有一个抽象方法的那种)
②再准备一个消费函数式接口的方法,方法的参数就是上面的那个函数式接口,然后方法里面要“简单的说明”如何使用这个函数式接口里面的抽象方法
③调用第②步的方法的时候就是用lambda表达式调用即可
lambda表达式在什么场景下用?
你可以看到①和②是前置条件,有了①②然后在③的地方使用lambda表达式
我们不是有常用的函数式接口吗,那些函数式接口就是为你准备好了第①步
有的还为你准备好了第②步的那些消费函数式接口的方法,比如Arrays.sort(xx)方法,这个方法的参数就是一个函数式接口
有了①和②你只需要就是在Arrays.sort(xx)的xxx的地方使用lambda表达式即可
二、Lambda表达式案例
1.Lambda表达式的标准格式
Lambda表达式的标准格式:
由三部分组成:
a.一些参数
b.一个箭头
c.一段代码
格式:
(参数列表) -> {一些重写方法的代码};
解释说明格式:
():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
->:传递的意思,把参数传递给方法体{}
{}:重写接口的抽象方法的方法体
public class Demo02Lambda {
public static void main(String[] args) {
//使用匿名内部类的方式,实现多线程
new Thread(new Runnable(){
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+" 新线程创建了");
}
}).start();
/*使用Lambda表达式,实现多线程。
方法的参数是一个函数式接口Runnable,你想一下它里面的唯一抽象方法是什么?
是个run()方法,没有参数,没有返回值,所以你就可以这样写:*/
new Thread(()->{
System.out.println(Thread.currentThread().getName()+" 新线程创建了");
}
).start();
//优化省略Lambda
new Thread(()->System.out.println(Thread.currentThread().getName()+" 新线程创建了")).start();
}
}
2.Lambda表达式无参数无返回值的练习
需求:
给定一个厨子Cook接口,内含唯一的抽象方法makeFood,且无参数、无返回值。
使用Lambda的标准格式调用invokeCook方法,打印输出“吃饭啦!”字样
public interface Cook {
//定义无参数无返回值的方法makeFood
public abstract void makeFood();
}
public class Demo01Cook {
public static void main(String[] args) {
//调用invokeCook方法,参数是Cook接口,传递Cook接口的匿名内部类对象
invokeCook(new Cook() {
@Override
public void makeFood() {
System.out.println("吃饭了");
}
});
//使用Lambda表达式,简化匿名内部类的书写
invokeCook(()->{
System.out.println("吃饭了");
});
//优化省略Lambda
invokeCook(()-> System.out.println("吃饭了"));
}
//定义一个方法,参数传递Cook接口,方法内部调用Cook接口中的方法makeFood
public static void invokeCook(Cook cook){
cook.makeFood();
}
}
3.Lambda表达式有参数有返回值的练习1
Lambda表达式有参数有返回值的练习
需求:
使用数组存储多个Person对象
对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Demo01Arrays {
public static void main(String[] args) {
//使用数组存储多个Person对象
Person[] arr = {
new Person("柳岩",38),
new Person("迪丽热巴",18),
new Person("古力娜扎",19)
};
//对数组中的Person对象使用Arrays的sort方法通过年龄进行升序(前边-后边)排序
Arrays.sort(arr, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o1.getAge()-o2.getAge();
}
});
//使用Lambda表达式,简化匿名内部类
Arrays.sort(arr,(Person o1, Person o2)->{
return o1.getAge()-o2.getAge();
});
//优化省略Lambda
Arrays.sort(arr,(o1, o2)->o1.getAge()-o2.getAge());
//遍历数组
for (Person p : arr) {
System.out.println(p);
}
}
}
4.Lambda表达式有参数有返回值的练习2
Lambda表达式有参数有返回值的练习
需求:
给定一个计算器Calculator接口,内含抽象方法calc可以将两个int数字相加得到和值
使用Lambda的标准格式调用invokeCalc方法,完成120和130的相加计算
public interface Calculator {
//定义一个计算两个int整数和的方法并返回结果
public abstract int calc(int a,int b);
}
public class Demo01Calculator {
public static void main(String[] args) {
//调用invokeCalc方法,方法的参数是一个接口,可以使用匿名内部类
invokeCalc(10, 20, new Calculator() {
@Override
public int calc(int a, int b) {
return a+b;
}
});
//使用Lambda表达式简化匿名内部类的书写
invokeCalc(120,130,(int a,int b)->{
return a + b;
});
//优化省略Lambda
invokeCalc(120,130,(a,b)-> a + b);
}
/* 定义一个方法,参数传递两个int类型的整数和Calculator接口,方法内部调用Calculator中的方法calc计算两个整数的和*/
public static void invokeCalc(int a,int b,Calculator c){
int sum = c.calc(a,b);
System.out.println(sum);
}
}
5.Lambda表达式无参无返回值
如 java.lang.Runnable 接口就是一个函数式接口,假设有一个 startThread 方法使用该接口作为参数,那么就 可以使用Lambda进行传参。
public class Demo01Runnable {
//定义一个方法startThread,方法的参数使用函数式接口Runnable
public static void startThread(Runnable run){
//开启多线程
new Thread(run).start();
}
public static void main(String[] args) {
//调用startThread方法,该方法的参数是一个接口,那么我们可以传递这个接口的匿名内部类
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了");
}
});
//startThread方法的参数Runnable是一个函数式接口,Runnable里面唯一的抽象方法是run()方法无参无返回值,用Lambda表达式来实现这个run
startThread(()->{
System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了");
});
//优化Lambda表达式
startThread(()->System.out.println(Thread.currentThread().getName()+"-->"+"线程启动了"));
}
}
三、Lambda表达式的省略格式
Lambda表达式:是可推导,可以省略
凡是根据上下文推导出来的内容,都可以省略书写
可以省略的内容:
1.(参数列表):括号中参数列表的数据类型,可以省略不写
2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
3.{一些代码}:如果{}中的代码只有一行,无论是否有返回值,都可以省略({},return,分号)
注意:要省略{},return,分号必须一起省略
欢迎纠错和指导,感谢浏览和收藏