文章底部有个人公众号：热爱技术的小郑。主要分享开发知识、学习资料、毕业设计指导等。个人B站主页热爱技术的小郑 ，视频内容主要是对应文章的视频讲解形式。有兴趣的可以关注一下。为何分享？ 踩过的坑没必要让别人在再踩，自己复盘也能加深记忆。利己利人、所谓双赢。

                                                                              热爱技术的小郑

前言

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;
    }
}