1、Lambda表达式
2、函数式接口
3、方法引用
4、Stream流
5、日期时间类
1、Lambda表达式
1.1、Lambda的由来
package demo01;
public class Test01 {
public static void main(String[] args) {
//开启一个线程 该构造函数需要传递一个Runnable类型的接口参数
Thread thread = new Thread(new My());
thread.start(); //开启线程
//匿名内部类
Thread thread1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println("使用匿名内部类类来完成-------------------->线程任务");
}
});
thread1.start(); //开启线程
}
}
class My implements Runnable{
@Override
public void run() {
System.out.println("使用实现类来完成-------------------->线程任务");
}
}
1.2、需求分析
-
Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
-
为了指定run方法体，不得不需要Runnable的实现类
-
为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
-
必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
-
而实际上，我们只在乎方法体中的代码.
1.3、初体验Lambda表达式
//Lambda表达式
Runnable runnable1=()->{
System.out.println("这是lambda表达式完成线程任务");
};
Thread thread2 = new Thread(runnable1);
thread2.start();
1.4、Lambda表达式的语法
Lambda省去了面向对象的条条框框，Lambda的标准格式由3个部分组成：
(参数列表)->{}
():参数列表
->:连接符 连接的是参数以及方法体。
{}: 方法体。
练习无参无返回值
package demo02;
public class Test02 {
public static void main(String[] args) {
//主函数调用fun方法 第一种：创建UserService接口的实现类，并创建该实现类对象
//第二种：匿名内部类方法
// UserService userService = new UserService() {
// @Override
// public void show() {
// System.out.println("这是匿名内部类的show方法实现");
// }
// };
// fun(userService);
//第三种：lambda表达式---该接口必须为函数式接口
UserService userService =()->{
System.out.println("lambda表示的show方法");
};
fun(userService);
}
public static void fun(UserService userService){
userService.show();
}
}
//函数式接口-->里面有且仅有一个抽象方法。--只有这种接口才能使用lambda表达式
@FunctionalInterface
interface UserService{
public void show();
}
练习有参有返回值
package demo03;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Test03 {
public static void main(String[] args) {
List<Person> personList = new ArrayList<>();
personList.add(new Person("张三",15));
personList.add(new Person("李四",5));
personList.add(new Person("王五",55));
personList.add(new Person("赵六",25));
personList.add(new Person("钱七",85));
//对集合中的元素按照年龄排序
//Collections：集合工具类
// Comparator<Person> comparator = new Comparator<Person>() {
// @Override //如果是0表示相同 大于0表示o1大于o2
// public int compare(Person o1, Person o2) {
// return o1.getAge()- o2.getAge();
// }
// };
// Collections.sort(personList,comparator);
// System.out.println(personList);
//就是对函数式接口中抽象方法的简写。
Comparator<Person> comparator=(o1,o2)->{
return o1.getAge()-o2.getAge();
};
Collections.sort(personList,comparator);
System.out.println(personList);
}
}
class Person{
private String name;
private Integer age;
public Person() {
}
public Person(String name, Integer age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public Integer getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(Integer age) {
this.age = age;
}
public String toString() {
return "Person{name = " + name + ", age = " + age + "}";
}
}
2.5、Lambda表达式的省略写法
在lambda表达式的标准写法基础上，可以使用省略写法的规则为：
-
小括号内的参数类型可以省略[]
-
如果小括号内有且仅有一个参数，则小括号可以省略
-
如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。
package demo04;
public class Test04 {
public static void main(String[] args) {
U01 u01 =a-> //省略小括号和大括号
System.out.println("加达里无畏舰:"+a);
fun(u01);
}
public static void fun(U01 u01){
u01.show("凤凰级");
}
}
interface U01{
public void show(String a);
}
2.6、Lambda表达式使用的前提
Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意
-
方法的参数或局部变量类型必须为接口才能使用Lambda
-
接口中有且仅有一个抽象方法(@FunctionalInterface)
后面我们使用lambda表达式主要核心使用再Stream流中
