前言
lambda运行将函数作为一个方法的参数，也就是函数作为参数传递到方法中。使用lambda表达式可以让代码更加简洁。
Lambda表达式的使用场景：用以简化接口实现
1 、简单使用
接口方法的实现
/**
* @author zyz
* @version 1.0
* @data 2023/8/25 11:36
* @Description: 关于接口实现，可以有很多种方式来实现。
* 例如：设计接口的实现类、使用匿名内部类。 但是lambda表达式，比这两种方式都简单。
*/
public class LambdaTest {
public static void main(String[] args) {
/**
* 使用lambda表达式实现接口
*/
TestDemo testDemo = () ->{
System.out.println("test");
};
testDemo.test();
}
}
@FunctionalInterface
interface TestDemo{
/**
* 测试方法
*/
public void test();
}
2、Lambda的基本语法
/**
* @author zyz
* @version 1.0
* @data 2023/8/25 11:45
* @Description: 基本语法
*/
public class LambdaTest2 {
public static void main(String[] args) {
/**
* 使用lambda表达式实现接口:
* 1、无参方法
* 2、有参 无返回值
* 3、有参 有返回值
*/
/**
* 1、无参方法
*/
Test01 t1 = () ->{
System.out.println("我是无参方法");
};
t1.test01();
/**
* 2、有参 无返回值
*/
Test02 t2 = (String name,int age) ->{
System.out.println("我是有参方法：姓名:" + name + ",年龄: " + age);
};
t2.test02("张三",18);
/**
* 3、有参 有返回值
*/
Test03 t3 = (name,age) ->{
int ageAfter = age + 4;
System.out.println("我是有参 有返回值方法：姓名:" + name + ",年龄: " + age);
return ageAfter;
};
int ageGet = t3.test03("李四",18);
System.out.println("四年后年龄：" + ageGet);
/**
* 精简写法:
* 1、省略传入参数的类型
* 2、方法参数列表只有一个，可以省略圆括号
* 3、当一个方法体中的逻辑，有且只有一句的情况，大括号可以省略
* 4、如果⼀个方法中唯⼀的⼀条语句是⼀个返回语句， 此时在省略掉大括号的同时， 也必须省略掉return。
*/
/**
* 1、省略传入参数的类型
*/
Test02 t21 = (name,age) ->{
System.out.println("我是有参方法：姓名:" + name + ",年龄: " + age);
};
t21.test02("张三",18);
/**
* 2、方法参数列表只有一个，可以省略圆括号
*/
Test04 t4 = age ->{
System.out.println("年龄是:" + age);
return age + 1;
};
t4.test04(18);
/**
* 3、方法体只有一句的情况，大括号可以省略
*/
Test02 t22 = (String name,int age) -> System.out.println("我是有参方法：姓名:" + name + ",年龄: " + age);
t22.test02("张三",18);
/**
* 4、如果⼀个方法中唯⼀的⼀条语句是⼀个返回语句， 此时在省略掉大括号的同时， 也必须省略掉return。
*/
Test04 t41 = age -> age + 1;
int ageGet1 = t41.test04(18);
System.out.println("精简写法,年龄加1:" + ageGet1);
}
}
/**
* 无参
*/
@FunctionalInterface
interface Test01{
public void test01();
}
/**
* 有参 无返回值
*/
@FunctionalInterface
interface Test02{
public void test02(String name,int age);
}
/**
* 有参 有返回值
*/
@FunctionalInterface
interface Test03{
public int test03(String name,int age);
}
/**
* 只有一个参数
*/
@FunctionalInterface
interface Test04{
public int test04(int age);
}
3、函数引用
3.1 静态方法/动态方法
/**
* @author zyz
* @version 1.0
* @data 2023/8/25 14:04
* @Description: 函数引用：
* 引用⼀个已经存在的方法，使其替代lambda表达式完成接口的实现
*/
public class LambdaTest3 {
public static void main(String[] args) {
/**
* 1、静态方法的引用。
* 语法：类::静态方法
* 注意:
* 在引用的方法后面，不要添加小括号。
* 引用的这个方法，参数（数量、类型）和返回值，必须要跟接口中定义的⼀致
*/
TestDemo01 testDemo = NumberTest::numberTest;
System.out.println(testDemo.test(5, 3));
/**
* 2、非静态方法的引用。
* 语法：对象::非静态方法
* 注意:
* 在引用的方法后面，不要添加小括号。
* 引用的这个方法，参数（数量、类型）和返回值，必须要跟接口中定义的⼀致
*/
TestDemo02 testDemo2 =new NumberTest()::numberTest02;
System.out.println(testDemo2.test(5, 3,2));
}
}
class NumberTest{
/**
* 静态方法
* @param a
* @param b
* @return
*/
public static int numberTest(int a ,int b){
if(a > b){
return a -b;
}else{
return b -a ;
}
}
/**
* 非静态方法的引用
* @param a
* @param b
* @param c
* @return
*/
public int numberTest02(int a,int b,int c){
if(a > b && a > c){
return b + c;
}else{
return a + b + c;
}
}
}
interface TestDemo01{
int test(int a,int b);
}
interface TestDemo02{
int test(int a,int b,int c);
}
3.2 构造方法的引用
/**
* @author zyz
* @version 1.0
* @Description:
* 语法：类名::new
* 注意事项：可以通过接口中的方法的参数， 区分引用不同的构造方法。
*/
public class LambdaTest4 {
public static void main(String[] args) {
//lambda表达式实现接口
GetDog getDog = Dog::new;
Dog dog = getDog.test();
System.out.println("无参构造函数:->" + "姓名:" + dog.name + "，年龄:" + dog.age);
GetDogWithParameter getDogWithParameter = Dog::new;
Dog dog1 = getDogWithParameter.test("赛虎",11);
System.out.println("有参构造函数:->" + "姓名:" + dog1.name + "，年龄:" + dog1.age);
}
}
/**
* 定义一个函数式接口,用以获取无参的对象
*/
@FunctionalInterface
interface GetDog {
/**
* 若此方法仅仅是为了获得一个Dog对象，而且通过无参构造去获取一个Dog对象作为返回值
*
* @return
*/
Dog test();
}
/**
* 定义一个函数式接口,用以获取有参的对象
*/
@FunctionalInterface
interface GetDogWithParameter {
/**
* 若此方法仅仅是为了获得一个Dog对象，而且通过有参构造去获取一个Dog对象作为返回值
*
* @param name
* @param age
* @return
*/
Dog test(String name, int age);
}
class Dog {
String name;
int age;
/**
* 无参构造
*/
public Dog() {
System.out.println("一个Dog对象通过无参构造被实例化了");
}
/**
* 有参构造
*
* @param name
* @param age
*/
public Dog(String name, int age) {
System.out.println("一个Dog对象通过有参构造被实例化了");
this.name = name;
this.age = age;
}
}
