day20Java-Thread-Lambda表达式
| 博客 |
|---|
| Java-(高级) |
文章目录
-
-
-
- Lambda表达式
- 冗余的Runnable代码
- 编程思想转换
- 使用Lambda标准格式（无参无返回）
- Lambda的参数和返回值
- 使用Lambda标准格式（有参有返回）
- Lambda省略格式
-
- 省略数据类型、返回值、{}、分号。
- 省略{}、分号。
- 省略数据类型、()、 {}、 return、 分号。
-
-
Lambda表达式
函数式编程思想概述:
在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。
面向对象的思想:
做一件事情,找一个能解决这个事情的对象,调用对象的方法,完成事情.
函数式编程思想:
只要能获取到结果,谁去做的,怎么做的都不重要,重视的是结果,不重视过程
冗余的Runnable代码
一方面，匿名内部类可以帮我们省去实现类的定义；另一方面，匿名内部类的语法——确实太复杂了！
传统写法
代码演示
public class LambdaDemo {
public static void main(String[] args) {
//创建线程对象
MyRunnable my = new MyRunnable();
//创建Thread对象
Thread t = new Thread(my);
//启动线程
t.start();
//Runnable接口匿名内部类实现多线程
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("启动线程了2");
}
};
//启动线程
new Thread(r).start();
//简化代码
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("启动线程3");
}
}) {
}.start();
}
}
自定义类实现Runnable接口
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("启动线程了1");
}
}
编程思想转换
做什么，而不是怎么做。
真的希望创建一个匿名内部类对象吗？不。我们只是为了做这件事情而不得不创建一个对象。我们真正希望做的事情是：将run方法体内的代码传递给Thread类知晓。
体验Lambda的更优写法
借助Java8的全新语法，上述Runnable接口的匿名内部类写法可以通过更简单的Lambda表达式达到等效：
Lambda表达式的标准格式:
由三部分组成:
a.一些参数
b.一个箭头
c.一段代码
格式:
(参数列表) -> {
一些重写方法的代码};
解释说明格式:
():接口中抽象方法的参数列表,没有参数,就空着;有参数就写出参数,多个参数使用逗号分隔
->:传递的意思,把参数传递给方法体{
}
{
}:重写接口的抽象方法的方法体
代码演示
public class LambdaDemo {
public static void main(String[] args) {
//匿名内部类方式启动线程
new Thread() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "启动线程1");
}
}.start();
//Lambda表示启动线程
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "启动线程2");
}).start();
}
}
结果:
Thread-1启动线程2
Thread-0启动线程1
使用Lambda标准格式（无参无返回）
给定一个厨子cook接口，内含唯一的抽象方法 makeFood ，且无参数、无返回值。如下：
public interface Cook {
public abstract void makeFood();
}
在下面的代码中，请使用Lambda的标准格式调用 invoke方法，打印输出“吃饭啦！”字样：
public class LambdaDemo {
public static void main(String[] args) {
//匿名内部类写法
invoke(new Cook() {
@Override
public void makeFood() {
System.out.println("吃饭了!");
}
});
//Lambda表达式
invoke(()->{
System.out.println("吃饭了!");
});
}
public static void invoke(Cook cook){
cook.makeFood();
}
}
接口:
public interface Cook {
public abstract void makeFood();
}
结果:
吃饭了!
吃饭了!
Lambda的参数和返回值
需求:使用数组存储多个Person对象 对数组中的Person对象使用Arrays的sort方法通过年龄进行升序排序。
代码演示
public class LambdaDemo {
public static void main(String[] args) {
Person[] arr = {
new Person("疾风剑豪", 33),
new Person("影流之主", 30),
new Person("刀锋之影", 34)
};
//匿名内部类写法
/* Arrays.sort(arr, new Comparator() {
@Override
public int compare(Person p1, Person p2) {
return p2.getAge()-p1.getAge();
}
});*/
//Lambda表达式
Arrays.sort(arr,(Person p1,Person p2)->{
return p1.getAge()-p2.getAge();
});
for (Person p:arr){
System.out.println(p);
}
}
}
实体类
package com.ginger.demo04;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
结果:
Person{
name='影流之主', age=30}
Person{
name='疾风剑豪', age=33}
Person{
name='刀锋之影', age=34}
使用Lambda标准格式（有参有返回）
给定一个计算器 Calculator 接口，内含抽象方法 calc 可以将两个int数字相加得到和值：
结果演示
public class LambdaDemo {
public static void main(String[] args) {
//匿名内部类实现
/*invoke(10, 20, new Calculator() {
@Override
public int calc(int a, int b) {
return a + b;
}
});*/
//Lambda表达式
int sum = invoke(100, 200, (int a, int b) -> {
return a + b;
});
System.out.println(sum);
}
public static int invoke(int a, int b, Calculator c) {
int sum = c.calc(a, b);
return sum;
}
}
接口
public interface Calculator {
public abstract int calc(int a,int b);
}
结果:
300
Lambda省略格式
Lambda表达式:是可推导,可以省略
凡是根据上下文推导出来的内容,都可以省略书写
可以省略的内容:
1.(参数列表):括号中参数列表的数据类型,可以省略不写
2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
3.{
一些代码}:如果{
}中的代码只有一行,无论是否有返回值,都可以省略({
},return,分号)
注意:要省略{
},return,分号必须一起省略
Lambda的使用前提
1. 使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。 无论是JDK内置的 Runnable 、 Comparator 接口还是自定义的接口，只有当接口中的抽象方法存在且唯一 时，才可以使用Lambda。
2. 使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
省略数据类型、返回值、{}、分号。
1.(参数列表):括号中参数列表的数据类型,可以省略不写
2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
3.{
一些代码}:如果{
}中的代码只有一行,无论是否有返回值,都可以省略({
},return,分号)
注意:要省略{
},return,分号必须一起省略
代码演示1
public class LambdaDemo {
public static void main(String[] args) {
//Lambda表达式
int sum = invoke(100, 200, (int a, int b) -> {
return a + b;
});
//简化Lambda表达式
//省略数据类型、返回值、{}、分号。
int sum2 invoke(10,20,(a,b)->a+b);
System.out.println(sum2);
}
public static int invoke(int a, int b, Calculator c) {
int sum = c.calc(a, b);
return sum;
}
}
//接口
interface Calculator {
public abstract int calc(int a,int b);
}
代码演示2
public class LambdaDemo {
public static void main(String[] args) {
Person[] arr = {
new Person("疾风剑豪", 33),
new Person("影流之主", 30),
new Person("刀锋之影", 34)
};
//Lambda表达式
Arrays.sort(arr, (Person p1, Person p2) -> {
return p1.getAge() - p2.getAge();
});
//简化Lambda表达式
//省略数据类型,返回值、{}、分号。
Arrays.sort(arr, (p1, p2) -> p1.getAge() - p2.getAge());
for (Person p : arr) {
System.out.println(p);
}
}
}
//实体类
class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
省略{}、分号。
1.(参数列表):括号中参数列表的数据类型,可以省略不写
2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
3.{
一些代码}:如果{
}中的代码只有一行,无论是否有返回值,都可以省略({
},return,分号)
注意:要省略{
},return,分号必须一起省略
代码演示1
public class LambdaDemo {
public static void main(String[] args) {
//匿名内部类写法
invoke(new Cook() {
@Override
public void makeFood() {
System.out.println("吃饭了!");
}
});
//Lambda表达式
invoke(() -> {
System.out.println("吃饭了!");
});
//简化Lambda表达式
//省略{}、分号。
invoke(() -> System.out.println("吃饭了!"));
}
public static void invoke(Cook cook) {
cook.makeFood();
}
}
interface Cook {
public abstract void makeFood();
}
代码演示2
public class LambdaDemo {
public static void main(String[] args) {
//Lambda表示启动线程
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "启动线程2");
}).start();
//简化Lambda表达式
//省略{}、分号
new Thread(()-> System.out.println(Thread.currentThread().getName() + "启动线程2")).start();
}
}
省略数据类型、()、 {}、 return、 分号。
1.(参数列表):括号中参数列表的数据类型,可以省略不写
2.(参数列表):括号中的参数如果只有一个,那么类型和()都可以省略
3.{
一些代码}:如果{
}中的代码只有一行,无论是否有返回值,都可以省略({
},return,分号)
注意:要省略{
},return,分号必须一起省略
代码演示
public class LambdaDemo {
public static void main(String[] args) {
int number = invoke(100, a -> a);
System.out.println(number);
}
public static int invoke(int a, Setinterface s) {
return s.set(100);
}
}
interface Setinterface {
public abstract int set(int number);
}