目录
一、Lambda表达式简介
什么是Lambda?
Lambda是JAVA 8添加的新特性,说白了,Lambda是一个匿名函数
为什么使用Lambda
使用Lambda表达式可以对一个接口的方法进行非常简洁的实现
Lambda对接口的要求
接口的抽象方法只能是一个,lambda表达式才能实现该接口
在JAVA8中 ,对接口加了一个新特性:default
可以使用default对接口方法进行修饰,被修饰的方法在接口中可以默认实现
@FunctionalInterface
修饰函数式接口的,接口中的抽象方法只有一个
二、Lambda的基础语法
—lambda表达式如何实现各类接口
1.语法
lambda表达式是实现一种接口的方式
()里面传入的是实现方法的参数列表
// 1.Lambda表达式的基础语法
// Lambda是一个匿名函数 一般关注的是以下两个重点
// 参数列表 方法体/**
* ():用来描述参数列表
* {}:用来描述方法体 有时可以省略
* ->: Lambda运算符 读作goes to
* 例 Test t=()->{System.out.println("hello word")}; 大括号可省略
*/
2.创建多个接口(准备工作)
—2、3代码复制粘贴就可以看到效果(jdk1.8以上)
无返回值无个参数 LambdaNoneReturnNoneParameter
无返回值单个参数 LambdaNoneReturnSingleParameter
无返回值多个参数 LambdaNoneReturnMulParameter
有返回值单个参数 LambdaSingleReturnSingleParameter
有返回值多个参数 LambdaSingleReturnMulParameter
public class Syntax {
public static void main(String[] args) {
}
}
//无返回值无参数
@FunctionalInterface
interface LambdaNoneReturnNoneParameter {
void test();
}
//无返回值单个参数
@FunctionalInterface
interface LambdaNoneReturnSingleParameter{
void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface LambdaNoneReturnMulParameter{
void test(int a, int b);
}
//有返回值单个参数
@FunctionalInterface
interface LambdaSingleReturnSingleParameter{
int test(int a);
}
//有返回值多个参数
@FunctionalInterface
interface LambdaSingleReturnMulParameter{
int test(int a, int b);
}
3.测试
System.out.println("<-----test01----->");
// 无返回值无个参数 LambdaNoneReturnNoneParameter
LambdaNoneReturnNoneParameter lambda01=()->{
System.out.println("test01");
};
lambda01.test();
System.out.println("<-----test02----->");
// 无返回值单个参数 LambdaNoneReturnSingleParameter
LambdaNoneReturnSingleParameter lambda02 = (a) -> {
System.out.println("test02"+"---"+a);
};
lambda02.test(123);
System.out.println("<-----test03----->");
// 无返回值多个参数 LambdaNoneReturnMulParameter
LambdaNoneReturnMulParameter lambda03 = (a, b) -> {
System.out.println("test03" + "-----" + (a + b));
};
lambda03.test(3,4 );
System.out.println("<-----test04----->");
// 有返回值单个参数 LambdaSingleReturnSingleParmter
LambdaSingleReturnSingleParameter lambda04 = (a) -> {
System.out.println("test04" + "---" + a);
return a;
};
System.out.println(lambda04.test(5));
System.out.println("<-----test05----->");
// 有返回值多个参数 LambdaSingleReturnMulParameter
LambdaSingleReturnMulParameter lambda05=(a,b)->{
System.out.println("test05"+"---"+a+b);
return a+b;
};
System.out.println(lambda05.test(3,4 ));
}
三、语法精简
1.参数类型精简
/**
* 语法精简
* 1.参数类型
* 由于在接口的抽象方法中,已经定义了参数的数量类型 所以在Lambda表达式中参数的类型可以省略
* 备注:如果需要省略类型,则每一个参数的类型都要省略,千万不要一个省略一个不省略
*/
@Test
public void test01() {
LambdaNoneReturnMulParameter lambda1 = (int a, int b) -> {
System.out.println("hello world"+a+b);
};
// 可以精简为:
LambdaNoneReturnMulParameter lambda1_ = (a, b) -> {
System.out.println("hello world"+a+b);
};
lambda1_.test(1, 2);
}
2.参数小括号精简
参数的数量只有一个,可以省略()
/**
* 2.参数小括号
* 如果参数列表中,参数的数量只有一个 此时小括号可以省略
*/
@Test
public void test02(){
LambdaNoneReturnSingleParameter lambda2=(a)->{
System.out.println("hello world"+a);
};
// 可以精简为:
LambdaNoneReturnSingleParameter lambda2_= a->{
System.out.println("hello world"+a);
};
lambda2_.test(1);
}
3.方法大括号精简
方法体中只有一条语句,可以省略{}
/**
* 3.方法大括号
* 如果方法体中只有一条语句,此时大括号可以省略
*/
@Test
public void test03(){
LambdaNoneReturnSingleParameter lambda3=a->{
System.out.println("hello world");
};
// 可以精简为:
LambdaNoneReturnSingleParameter lambda3_=a->System.out.println("hello world");
lambda3_.test(2);
}
4.大括号精简补充
方法体中唯一的一条语句是一个返回语句,可以省略return
/**
* 4.如果方法体中唯一的一条语句是一个返回语句
* 贼省略大括号的同时 也必须省略return
*/
@Test
public void test04(){
LambdaSingleReturnNoneParameter lambda4=()->{
return 10;
};
// 可以精简为:
LambdaSingleReturnNoneParameter lambda4_=()->10;
System.out.println(lambda4_.test());
}
5.多参数,有返回值精简
@Test
public void test05(){
LambdaSingleReturnMulParameter lambda5=(a,b)->{
return a+b;
};
// 可以精简为:
LambdaSingleReturnMulParameter lambda5_=(a,b)->a+b;
System.out.println(lambda5_.test(1, 2));
}
四、Lambda语法进阶
—引用其他方法实现接口
1.方法引用(普通方法与静态方法)
在实际应用过程中,一个接口在很多地方都会调用同一个实现,例如:
LambdaSingleReturnMutipleParmeter lambda1=(a,b)->a+b;
LambdaSingleReturnMutipleParmeter lambda2=(a,b)->a+b;
这样一来每次都要写上具体的实现方法 a+b,如果需求变更,则每一处实现都需要更改,基于这种情况,可以将后续的是实现更改为已定义的方法,需要时直接调用就行
语法
/**
*方法引用:
* 可以快速的将一个Lambda表达式的实现指向一个已经实现的方法
* 方法的隶属者 如果是静态方法 隶属的就是一个类 其他的话就是隶属对象
* 语法:方法的隶属者::方法名
* 注意:
* 1.引用的方法中,参数数量和类型一定要和接口中定义的方法一致
* 2.返回值的类型也一定要和接口中的方法一致
*/
例:
public class Syntax {
public static void main(String[] args) {
LambdaSingleReturnSingleParameter lambda1=a->a*2;
LambdaSingleReturnSingleParameter lambda2=a->a*2;
LambdaSingleReturnSingleParameter lambda3=a->a*2;
//简化
LambdaSingleReturnSingleParameter lambda4=a->staticMethod(a);
//方法引用
LambdaSingleReturnSingleParameter lambda5=Syntax::staticMethod;
}
public static int staticMethod(int a){
return a*2;
}
}
2.方法引用(构造方法)
需求
两个接口,各有一个方法,一个接口的方法需要引用Person的无参构造,一个接口的方法需要引用Person的有参构造 用于返回两个Person对象,例:
准备(还需要之前定义的接口,在二的2中):
package lambda;
public class Syntax1 {
public static void main(String[] args) {
}
}
class Person {
public String name;
public int age;
public Person() {
System.out.println("Person的无参构造方法执行");
}
public Person(String name, int age) {
this.name = name;
this.age = age;
System.out.println("Person的有参构造方法执行");
}
}
interface PersonCreater01{
//通过Person的无参构造实现
Person getPerson();
}
interface PersonCreater02{
//通过Person的有参构造实现
Person getPerson(String name,int age);
}
测试:
PersonCreater01 creater=()->new Person();
//引用的是Person的无参构造
//PersonCreater接口的方法指向的是Person的方法
PersonCreater01 creater1=Person::new; //等价于上面的()->new Person()
//实际调用的是Person的无参构造 相当于把接口里的getPerson()重写成new Person()。
Person a=creater1.getPerson();
//引用的是Person的有参构造
PersonCreater02 creater2=Person::new;
Person b=creater2.getPerson("张三",18);