Lambda表达式
一、基本概念
1、两种编程思想
面向对象：做一件事，找一个能解决这个事情的对象，调用对象的方法，完成事情
函数式编程：只要能获取到结果就行，不管谁去做，怎么做，注重结果，不看过程
2、Lambda表达式的标准格式
使用Runnable接口的实现类来创建多线程
public class RunnableImpl implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新的线程创建了");
}
}
public class Demo01Runnable {
public static void main(String[] args) {
Runnable run = new RunnableImpl();
Thread t = new Thread(run);
t.start();
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新的线程创建了");
}
};
new Thread(r).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新的线程创建了");
}
}).start();
}
}
匿名内部类的好处和弊端：省去了类的定义，但语法太复杂了
使用Runnable接口的实现类来创建多线程的方式，有很多冗余的代码，我们并不是真的希望创一个匿名内部类对象，我们真正想做的是传递一行代码（run方法中的）。JDK1.8之后，Lambda表达式的重量级特性，为我们打开了新世界的大门。
使用Lambda的标准方式创建多线程
public class Demo02Lambda {
public static void main(String[] args) {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"新的线程创建了");
}
}).start();
new Thread(() -> {
System.out.println(Thread.currentThread().getName()+"新的线程创建了");
}).start();
}
}
Lambda表达式的标准格式
三部分组成，参数、箭头、一段代码。
格式：(参数列表)->{一些重写方法的代码};
():接口中抽象方法的参数列表，没有参数就是空的，有参数就写出参数
->:传递的意思，把参数传递给方法体
{}:重写接口的抽象方法的方法体
二、Lambda表达式使用
1、Lambda标准格式（无参无返回值）
练习：Lambda标准格式（无参无返回值）
给定一个厨子Cook接口，内含唯一的抽象方法makeFood，无参数无返回值。使用Lambda的标准格式调用invokeCook方法，打印输出"吃饭啦！"字样。
public interface Cook {
void makeFood();
}
public class Demo01Cook {
public static void main(String[] args) {
invokeCook(new Cook() {
@Override
public void makeFood() {
System.out.println("吃饭啦");
}
});
invokeCook(()->{
System.out.println("吃饭啦");
});
}
public static void invokeCook(Cook cook) {
cook.makeFood();
}
}
2、Lambda标准格式（有参数有返回值）
练习1：
使用数组存储多个Person对象，对数组中的Person对象使用Arrays.sort方法通过年龄进行升序排序。
public 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 Demo01Array {
public static void main(String[] args) {
Person[] arr = {
new Person("迪丽热巴",22),
new Person("古力娜扎",18),
new Person("赵老师",23)
};
Arrays.sort(arr, (o1, o2) -> o1.getAge()-o2.getAge());
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
上述代码使用了匿名内部类、Lambda表达式的标准格式以及简化方式实现了排序。
练习2：
给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值。使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算。
public interface Calculator {
int calc(int a, int b);
}
public class Demo01Calculator {
public static void main(String[] args) {
invokeCalc(120, 130, (int a, int b) ->{
return a + b;
});
invokeCalc(12,13,(a,b)-> a+b);
}
public static void invokeCalc(int a,int b,Calculator c){
int sum = c.calc(a,b);
System.out.println(sum);
}
}
3、使用总结
Lambda表达式是可推导的，所以和泛型的使用一样，是可以省略的。范式根据上下文推导出来的内容，都可以省略书写。可以省略的内容：
- (参数列表):括号中参数列表的数据类型，可以省略不写
- (参数列表):括号中的参数如果只有一个，那么类型和()都可以省略不写
- {代码}:如果{}中的代码只有一行，无论是否有返回值，都可以省略({},return,分号) 注意：{},return,分号必须一起省略
Lambda的使用前提：
（1）使用Lambda必须具有接口，且接口汇总有且仅有一个抽象方法。无论是JDK内置的Runnbale、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
（2）使用Lambda必须具有上下文推断。也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例（只有一个抽象方法的时候才能根据上下文推断出来是什么内容）。
注意：有且仅有一个抽象方法的接口，称为"函数式接口"。
最后，真正只有一个抽象方法的接口比较少，所以使用场景不是很多，了解。
|