目录
Lambda 表达式简介
【什么是Lambda】
Lambda是Java 8添加的一个新特性。说白了,Lambda就是一个匿名函数
【为什么要使用Lambda】
使用Lambda表达式可以对一个接口进行非常简洁的实现
【Lambda对接口的要求】
虽然可以使用Lambda表达式对某些接口进行简单的实现,但是并不是所有的接口都可以用Lambda表达式来实现。要求接口中定义的必须要实现的抽象方法只能是一个
@FunctionInterface标记
Lambda 表达式
Lambda是一个匿名函数,主要由:【参数列表】和【方法体】组成
【格式】
- (): 用来描述参数列表
- {}: 用来描述方法体
- ->: lambda运算符,读作goes to
import interfaces.LambdaNoneReturnMutipleParameter;
import interfaces.LambdaNoneReturnNoneParameter;
import interfaces.LambdaNoneReturnSingleParameter;
import interfaces.LambdaSingleReturnMutipleParameter;
import interfaces.LambdaSingleReturnNoneParameter;
import interfaces.LambdaSingleReturnSingleParameter;
/**
* @ClassName: LambdaTest
* @description: lambda测试
* @author: FFIDEAL
* @Date: 2020年3月2日 下午10:10:11
*/
public class LambdaTest {
public static void main(String[] args) {
//1.lambda表达式的基本语法
//Lambda是一个匿名函数
//参数列表 方法体
//(): 用来描述参数列表
//{}: 用来描述方法体
//->: lambda运算符,读作goes to
//无参数无返回值的
LambdaNoneReturnNoneParameter lambdatest1 = () -> {
System.out.println("hello world");
};
lambdatest1.test();
//一个参数无返回值
LambdaNoneReturnSingleParameter lambdatest2 = (int a) -> {
System.out.println(a);
};
lambdatest2.test(20);
//多个参数无返回值
LambdaNoneReturnMutipleParameter lambdatest3 = (int a, int b) ->{
System.out.println(a + b);
};
lambdatest3.test(20, 30);
//无参数有返回值
LambdaSingleReturnNoneParameter lambdatest4 = () -> {
return 60;
};
System.out.println(lambdatest4.test());
//有返回值单个参数
LambdaSingleReturnSingleParameter lambdatest5 = (int a) -> {
return a;
};
System.out.println(lambdatest5.test(70));
//有返回值多个参数
LambdaSingleReturnMutipleParameter lambdatest6 = (int a,int b) -> {
return a + b;
};
System.out.println(lambdatest6.test(30, 50));
}
}
/**
* @ClassName: Createlambda
* @description: 三种实现接口的方法,其中重点是lambda表达式,这种方法更简洁
* @author: FFIDEAL
* @Date: 2020年3月2日 下午9:32:28
*/
public class Createlambda {
public static void main(String[] args) {
// 1.通过接口实现类的方式
Compare compare = new MyCompare();
// 2.使用匿名内部类的方式
Compare compare1 = new Compare() {
@Override
public int compare(int a, int b) {
// TODO Auto-generated method stub
return a - b;
}
};
// 3.使用lambda表达式的方式实现接口
Compare compare2 = (a, b) -> a - b;
}
}
//创建一个实现接口的类
class MyCompare implements Compare {
@Override
// 重写Compare接口中的方法
public int compare(int a, int b) {
return a - b;
}
}
@FunctionalInterface
//上面注释是检查接口中是否只有一个方法:函数式接口
interface Compare {
// 创建一个接口
int compare(int a, int b);
}
Lambda 语法精简
语法精简的四条规则
- 参数类型。因为在接口中的抽象方法已经确定了参数类型,所以此时不用写参数类型
注意:要省略参数类型就一起省略,不能出现有的省略,有的不省略的情况 - 当只有一个参数的时候,可以省略括号
- 当方法体中只有一条语句时,可以去掉大括号
- 当方体中只有一条返回语句且去掉大括号时,需同时把return去掉
import interfaces.LambdaNoneReturnMutipleParameter;
import interfaces.LambdaNoneReturnSingleParameter;
import interfaces.LambdaSingleReturnSingleParameter;
/**
* @ClassName: LambdaClear
* @description: Lambda语法精简
* @author: FFIDEAL
* @Date: 2020年3月3日 下午1:38:35
*/
public class LambdaClear {
public static void main(String[] args) {
//1.参数类型。因为在接口中的抽象方法已经确定了参数类型,所以此时不用写参数类型
//注意:要省略参数类型就一起省略,不能出现有的省略有的不省略的情况
LambdaNoneReturnMutipleParameter lc1 = (a , b) -> {
System.out.println(a + b);
};
lc1.test(1, 2);
//2.当只有一个参数的时候,可以省略括号
LambdaNoneReturnSingleParameter lc2 = a -> {
System.out.println(a);
};
lc2.test(4);
//3.当方法体中只有一条语句时,可以去掉大括号
LambdaNoneReturnSingleParameter lc3 = a -> System.out.println(a);
lc3.test(5);
//4.当方体中只有一条返回语句且去掉大括号时,需同时把return去掉
LambdaSingleReturnSingleParameter lc4 = a -> a;
System.out.println(lc4.test(6));
}
}
Lambda 方法引用
方法引用的规则:
- 方法引用:可以快速的一个Lambda表达式的实现直线一个已经实现了的方法
- 语法:方法隶属者::方法名
注意:
- 返回数量和类型一定要和接口中定义的方法一致
- 返回值的类型一定要和接口中定义的方法一致
import interfaces.LambdaSingleReturnSingleParameter;
/**
* @ClassName: LambdaFunction
* @description: 方法引用
* @author: FFIDEAL
* @Date: 2020年3月3日 下午2:06:54
*/
public class LambdaFunction {
public static void main(String[] args) {
/*
* 方法引用:
* 可以快速的一个Lambda表达式的实现直线一个已经实现了的方法
* 语法:方法隶属者::方法名
*
* 注意:
* 1.返回数量和类型一定要和接口中定义的方法一致
* 2.返回值的类型一定要和接口中定义的方法一致
* */
LambdaSingleReturnSingleParameter lf1 = a -> change(a) ;
System.out.println(LambdaFunction.change(10));
//方法引用:静态引用了change方法的实现
LambdaSingleReturnSingleParameter lf2 = LambdaFunction::change;
System.out.println(LambdaFunction.change(20));
LambdaFunction lf = new LambdaFunction();
//方法引用:非静态引用了goesTo方法的实现
LambdaSingleReturnSingleParameter lf3 = a -> lf.goesTo(a);
System.out.println(lf.goesTo(30));
LambdaSingleReturnSingleParameter lf4 = lf :: goesTo;
System.out.println(lf.goesTo(40));
}
//创建一个静态方法
private static int change(int a) {
return a * 12 ;
}
//创建一个非静态方法
private int goesTo(int a) {
return a * 21 ;
}
}
Lambda 构造方法引用
/**
* @ClassName: LambdaTest2
* @description: 构造方法
* @author: FFIDEAL
* @Date: 2020年3月3日 下午2:54:11
*/
public class LambdaTest2 {
public static void main(String[] args) {
//构造方法的引用
PersonCreater pc = Person4::new;
Person4 a = pc.getPerson();
PersonCreater2 pc2 = Person4 :: new;
Person4 b = pc2.getPerson("张三", 5);
}
}
interface PersonCreater{
Person4 getPerson();
}
interface PersonCreater2{
Person4 getPerson(String name,int age);
}
Lambda 综合练习
/**
* @ClassName: Person
* @description:
* @author: FFIDEAL
* @Date: 2020年3月3日 下午2:50:09
*/
public class Person4 {
private String name;
int age;
public Person4(){
System.out.println("运行了无参构造器");
}
public Person4(String name, int age) {
this.name = name;
this.age = age;
System.out.println("运行了有参数构造器");
}
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 String toString() {
return "name:" + name + "age: " + age ;
}
}
案例1:集合排序
import java.util.ArrayList;
/**
* @ClassName: LambdaList
* @description: 集合排序。按年龄降序
* @author: FFIDEAL
* @Date: 2020年3月3日 下午3:08:49
*/
public class LambdaList {
public static void main(String[] args) {
ArrayList<Person4> list = new ArrayList<Person4>();
list.add(new Person4("LiMing",20));
list.add(new Person4("WangJin",22));
list.add(new Person4("LiuDehua",21));
list.sort((o1 , o2) -> o1.age - o2.age);
System.out.println(list);
}
}
案例2:TreeSet
import java.util.TreeSet;
/**
* @ClassName: LambdaSet
* @description: Tree Set
* @author: FFIDEAL
* @Date: 2020年3月3日 下午3:27:06
*/
public class LambdaSet {
public static void main(String[] args) {
//使用Lambda表达式来实现Comparator接口,并实例化一个TreeSet对象
TreeSet<Person4> ts = new TreeSet<Person4>((o1 , o2) -> o1.age - o2.age);
ts.add(new Person4("LiMing",20));
ts.add(new Person4("WangJin",22));
ts.add(new Person4("LiuDehua",21));
System.out.println(ts);
}
}
案例3:删除符合条件的对象(removeIf)
import java.util.ArrayList;
import java.util.ListIterator;
/**
* @ClassName: LambdaDelete
* @description: 删除集合中满足条件的语句
* @author: FFIDEAL
* @Date: 2020年3月3日 下午3:44:28
*/
public class LambdaDelete {
public static void main(String[] args) {
ArrayList<Person4> list = new ArrayList<Person4>();
list.add(new Person4("LiMing",20));
list.add(new Person4("WangJin",22));
list.add(new Person4("LiuDehua",21));
/*
ListIterator<Person4> it = list.listIterator();
while(it.hasNext()) {
Person4 ele = it.next();
if(ele.age > 21) {
it.remove();
}
}
System.out.println(list);
*/
list.removeIf(ele -> ele.age > 21);
System.out.println(list);
}
}
案例4:开辟一个线程,做一个线程的数字输出
/**
* @ClassName: LambdaThread
* @description: 开辟一条线程,做一个数字输出
* @author: FFIDEAL
* @Date: 2020年3月3日 下午3:57:13
*/
public class LambdaThread {
public static void main(String[] args) {
Thread t = new Thread(() -> {
for(int i = 0; i < 100; i++) {
System.out.println(i);
}
});
t.start();
}
}