基本写法及代码实现

样例1

定义一个接口：

package com.shadow.lambda.demo01;

/**
 * <p>@Description  </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2023-03-20 </p>
 **/
public interface Factory {

    Object getObject();
}

定义接口的实现类：

package com.shadow.lambda.demo01;

/**
 * <p>@Description  </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2023-03-20 </p>
 **/
public class SubClass implements Factory{
    @Override
    public Object getObject() {
        return new User();
    }
}

实体类：

package com.shadow.lambda.demo01;

/**
 * <p>@Description  </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2023-03-20 </p>
 **/
public class User {

    private String name;

    private int age;

    public User() {
        super();
    }

    public User(String name, int age) {
        this.name = name;
        this.age = 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;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

Lambda测试类：

package com.shadow.lambda.demo01;

/**
 * <p>@Description  Lambda表达式初体验
 * 代码更简洁
 * 函数式编程：更关注函数/功能，而非对象
 * 函数是 第一等公民
 * 可以赋值给变量
 * 可以作为（其他函数的）参数进行传递
 * 可以作为（其他函数的）返回值
 * </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2023-03-20 </p>
 **/
public class LambdaTest {

    public static void main(String[] args) {
        //1.子类实现接口
        Factory factory = new SubClass();
        User user1 = (User) factory.getObject();
        System.out.println(user1);

        //2.匿名内部类
        factory = new Factory() {
            @Override
            public Object getObject() {
                return new User("张三", 29);
            }
        };
        User user2 = (User) factory.getObject();
        System.out.println(user2);

        //3.Lambda表达式
        factory = () -> {
            return new User("李四", 28);
        };
        User user3 = (User) factory.getObject();
        System.out.println(user3);

        //函数体中只有简单的表达式语句时，大括号可以省略
        factory = () -> new User("王五", 27);
        User user4 = (User) factory.getObject();
        System.out.println(user4);

        //Lambda作为参数进行传递
        User user5 = getUserFromFactory(factory, "User");
        System.out.println(user5);

        User user6 = getUserFromFactory(() -> {
            return new User("赵六", 26);
        }, "User");
        System.out.println(user6);

        //Lambda作为函数的返回值
        factory = getFactory();
        User user7 = (User) factory.getObject();
        System.out.println(user7);
    }

    public static User getUserFromFactory(Factory factory, String beanName) {
        Object object = factory.getObject();
        if (object != null && object.getClass().getSimpleName().equals(beanName)) {
            return (User) object;
        }
        return null;
    }

    public static  Factory getFactory(){
        return () -> new User("钱七",25);
    }
}

样例2

定义接口：

package com.shadow.lambda.demo02;

/**
 * <p>@Description  </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2023-03-20 </p>
 **/
public interface IGreeting {

    void sayHello(String msg);
}

package com.shadow.lambda.demo02;

/**
 * <p>@Description  </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2023-03-20 </p>
 **/
@FunctionalInterface
public interface IMathOperation {
    int operation(int a, int b);
}

测试类：

package com.shadow.lambda.demo02;

/**
 * <p>@Description  Lambda表达式测试类
 * 语法：
 * (parameters) -> {statements;}
 * 或
 * (parameters) -> expression
 * Lambda表达式与函数式接口的抽象函数格式一一对应
 * 前提：必须要有一个函数式接口（@FunctionalInterface）
 * </p>
 * <p>@Author      Shadow.Yu </p>
 * <p>@Date        2023-03-20 </p>
 **/
public class LambdaSyntaxTest {

    public static void main(String[] args) {
        //1.基本格式
        IMathOperation iMathOperation1 = (int a, int b) -> {return a + b;};
        System.out.println(iMathOperation1.operation(1, 2));

        //2.省略大括号
        IGreeting iGreeting = (String msg) -> System.out.println("Hello " + msg);
        iGreeting.sayHello("Lambda");

        //3.省略小括号
        iGreeting = msg -> System.out.println("Hello " + msg);
        iGreeting.sayHello("Lambda2");

        //4.省略return
        IMathOperation iMathOperation2 = (int a, int b) -> a + b;
        System.out.println(iMathOperation2.operation(3, 4));

        //5.省略参数类型和大括号
        IMathOperation iMathOperation3 = (a, b) -> a + b;
        System.out.println(iMathOperation3.operation(4, 5));
    }
}