JDK8新特性：lambda表达式

BEGIN

lambda表达式是jdk8的新特性，函数式编程，代替匿名内部类
虽然说我很讨厌这个东西，但是很多大佬都写这个，看不懂可不行，而且大佬们用这个总有他的道理，学一学。

1.lambda基本语法

package com.zky.lambda;

interface Add {
    int add(int a, int b);
}

/**
 *
 * @author: yuan
 * @date: 2023/2/12
 * @Description: lambda基础语法
 */
public class DemoLambda {
    public static void main(String[] args) {
        System.out.println("lambda~~~ ");

        //匿名内部类实现接口的方法
        Add ad = new Add() {
            @Override
            public int add(int a, int b) {
                return a + b;
            }
        };

        System.out.println("匿名内部类："+ad.add(3, 2));//匿名内部类：5

        /**
         *
         * @author: yuan
         * @date: 2023/2/12
         * @Description: lambda表达式实现接口的方法
         *              ()里面是参数
         *              ->是固定格式
         *              {}里面是函数体，具体实现
         */
        Add ad1 = (int a, int b) -> {
            //函数体
            return a + b;
        };

        System.out.println("lambda:"+ad1.add(3,2));//lambda:5

    }
}

2.lambda的简单运用

package com.zky.lambda;

interface Test1 {

    /**
     * 无参数无返回值
     */
    void test();
}

interface Test2 {

    /**
     * 有一个参数有返回值
     */
    int test(int a);
}

interface Test3 {

    /**
     * 有一个参数无返回值
     */
    void test(int a);
}

interface Test4 {

    /**
     * 有两个参数有返回值
     */
    int test(int a, int b);
}

interface Test5 {

    /**
     * 有两个参数无返回值
     */
    void test(int a, int b);
}

interface Test6 {

    /**
     * 无参数有返回值
     */
    int test();
}

/**
 *
 * @author: yuan
 * @date: 2023/2/12
 * @Description:  lambda的简单运用
 */
public class DemoLambda2 {
    public static void main(String[] args) {
        //1.无参数无返回值
        Test1 test1 = () -> {
            System.out.println("1.无参数无返回值");
        };
        test1.test();

        //2.有一个参数有返回值
        Test2 test2 = (int a) -> {
            return a * 2;
        };
        System.out.println("2.有一个参数有返回值:" + test2.test(3));

        //3.有一个参数无返回值
        Test3 test3 = (int a) -> {
            System.out.println("3.有一个参数无返回值:" + a);
        };
        test3.test(3);

        //4.有两个参数有返回值
        Test4 test4 = (int a, int b) -> {
            return a + b;
        };
        System.out.println("4.有两个参数有返回值:" + test4.test(4, 4));

        //5.有两个参数无返回值
        Test5 test5 = (int a, int b) -> {
            System.out.println("5.有两个参数无返回值:" + (a + b));
        };
        test5.test(2,3);

        //6.无参数有返回值
        Test6 test6 = ()->{
            return 6;
        };
        System.out.println("6.无参数有返回值:"+test6.test());

    }
}

3.lambda表达式的精简使用（省略写法）

package com.zky.lambda;

public class DemoLambda3 {

    /**
     * @author: yuan
     * @date: 2023/2/12
     * @Description: lambd的精简使用
     */
    public static void main(String[] args) {
        //1.参数类型可以省略
        Test2 test1 = (a) -> {
            return a * 2;
        };
        System.out.println("1.参数类型可以省略:" + test1.test(3));

        //2.两个类型的参数都要省略
        Test4 test2 = (a, b) -> {
            return a + b;
        };
        System.out.println("2.两个类型的参数都要省略:" + test2.test(4, 4));

        //3.单参数时，()可以省略
        Test2 test3 = a -> {
            return a * 2;
        };
        System.out.println("3.参数类型可以省略:" + test3.test(3));

        //4.若是方法体只有一个语句，{}也可省略
        Test3 test4 = (a) -> System.out.println("4.若是方法体只有一个语句，{}也可省略:" + a);
        test4.test(4);

        //5.有返回值的函数{}要连着return一同省略
        Test4 test5 = (a, b) -> a + b;
        System.out.println("5.有返回值的函数{}要连着return一同省略:" + test5.test(4, 4));
    }
}

4.lambda的方法引用

package com.zky.lambda;

public class DemoLambda4 {

    /**
     * @author: yuan
     * @date: 2023/2/12
     * @Description: 方法引用
     *              当多个lambda表达式实现的函数相同时，我们可以封装成一个通用方法，然后用lambda表达式调用
     */

    //定义一个方法
    public int sum(int a, int b) {
        return a + b;
    }

    public static int sum2(int a,int b){
        return a + b;
    }

    public static void main(String[] args) {
        //实例化对象
        DemoLambda4 demoLambda4 = new DemoLambda4();

        //用对象和双冒号::调用方法来实现接口
        Test4 test4 = demoLambda4::sum;
        System.out.println("用对象和双冒号::调用方法来实现接口:"+test4.test(2,2));

        //用类名和双冒号::调用静态方法来实现
        Test4 test41 = DemoLambda4::sum2;
        System.out.println("用类名和双冒号::调用方法来实现:"+test41.test(2,2));
    }
}

5.lambda的构造方法引用

先创建一个实体类，添加有参构造方法和无参构造方法

package com.zky.lambda;

/**
 * @author: yuan
 * @date: 2023/2/12
 * @Description: 实体类
 */
public class Dog {

    private String name;

    private int age;

    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 Dog() {
        System.out.println("空参构造方法");
        this.name = "默认";
        this.age = 0;
    }

    public Dog(String name, int age) {
        System.out.println("有参构造方法");
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog: {" +
                "name:" + name +
                "  age:" + age +
                "}";
    }
}

构造方法的调用

package com.zky.lambda;

interface DogService {
    Dog getDog();
}

interface DogService2 {
    Dog getDog(String name, int age);
}

/**
 * @author: yuan
 * @date: 2023/2/12
 * @Description: lambda构造方法引用
 */
public class DemoLambda5 {
    public static void main(String[] args) {
        //1.空差构造方法
        DogService dogService1 = () -> {
            return new Dog();
        };
        System.out.println(dogService1.getDog());

        //2.省略写法
        DogService dogService2 = () -> new Dog();
        System.out.println(dogService2.getDog());

        //3.用类名加双冒号调用new (不能用对象)
        DogService dogService3 = Dog::new;
        System.out.println(dogService3.getDog());

        //4.有参构造方法
        DogService2 dogService4 = (String name, int age) -> {
            return new Dog(name, age);
        };
        System.out.println(dogService4.getDog("大黑", 3));

        //5.省略写法
        DogService2 dogService5 = (name, age) -> new Dog(name, age);
        System.out.println(dogService5.getDog("大黑", 3));

        //6.用类名加双冒号调用new
        DogService2 dogService6 = Dog::new;
        System.out.println(dogService6.getDog("大黑",3));
    }
}

6.lambda集合运用

package com.zky.lambda;


import java.util.ArrayList;
import java.util.List;

/**
 *
 * @author: yuan
 * @date: 2023/2/12
 * @Description: 集合运用
 */

public class DemoLambda6 {
    public static void main(String[] args) {
        List<Dog> list = new ArrayList<>();

        list.add(new Dog("大黑",2));
        list.add(new Dog("老黑",3));
        list.add(new Dog("小黑",1));

        //lambda表达式排序
        list.sort((o1,o2)->{
            return o2.getAge()-o1.getAge();
        });
        System.out.println(list);

        //打印list，lambda表达式循环遍历集合
        list.forEach(System.out::println);

    }
}

7.stream运用lambda表达式

（待更新）