Java8 Lambda 表达式

package com.test.java8;

/**
 * Lambda 表达式
 *
 * @author smallk
 * @date 2018/12/4 16:50
 */
public class LambdaTest {

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest();

        // 无参输出
        NotParams notParams = () -> System.out.println("无参输出");
        lambdaTest.out(notParams);

        // 可选的大括号：如果主体包含了一个语句，就不需要使用大括号
        ExecuteStatement executeStatement = msg -> {
            msg += " World";
            System.out.println("世界语:" + msg);
        };
        lambdaTest.execute("Hello", executeStatement);

        // 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号
        MathAbs mathAbs = a -> a < 0 ? -a : a;
        System.out.println("绝对值:" + lambdaTest.backAbs(-2, mathAbs));

        // 有参数类型声明
        MathOperation addition = (int a, int b) -> a + b;
        System.out.println("有参数类型声明:" + lambdaTest.operate(10, 2, addition));

        // 无参数类型声明
        MathOperation subtraction = (a, b) -> a - b;
        System.out.println("无参数类型声明:" + lambdaTest.operate(10, 5, subtraction));

        // 主体只有一个表达式返回值且使用了大括号则必须写 return 关键字
        MathOperation multiplication = (a, b) -> {
            return a * b;
        };
        System.out.println("大括号中的返回语句:" + lambdaTest.operate(3, 5, multiplication));

        // 主体只有一个表达式返回值且无大括号则编译器会自动返回值
        MathOperation division = (a, b) -> a / b;
        System.out.println("无大括号中的返回语句:" + lambdaTest.operate(15, 5, division));

        // 实现函数式接口
        GreetingService greetingService1 = msg -> System.out.println("msg:" + msg);
        greetingService1.sayMessage("你的名字");

        String salutation = "salutation:";
        // 报错 Variable used in lambda expression should be final or effectively final
        // salutation = "salutation:";
        GreetingService greetService2 = msg -> System.out.println(salutation + msg);
        greetService2.sayMessage("123");

        // 函数式接口另一种写法
        MathOperation mathOperation = (a, b) -> a + b;
        System.out.println(mathOperation.addition(4, 8));
    }

    /**
     * 函数式接口只能有一个抽象方法
     */
    interface NotParams {

        /**
         * 无参输出
         */
        void out();
    }

    private void out(NotParams notParams) {
        notParams.out();
    }

    /**
     * 函数式接口只能有一个抽象方法
     */
    interface ExecuteStatement {

        /**
         * 执行代码
         *
         * @param msg msg
         */
        void execute(String msg);
    }

    private void execute(String msg, ExecuteStatement executeStatement) {
        executeStatement.execute(msg);
    }

    /**
     * 函数式接口只能有一个抽象方法
     */
    interface MathAbs {

        /**
         * 返回绝对值
         *
         * @param a a
         * @return int
         */
        int backAbs(int a);
    }

    private int backAbs(int a, MathAbs mathAbs) {
        return mathAbs.backAbs(a);
    }

    /**
     * 函数式接口只能有一个抽象方法
     */
    interface MathOperation {

        /**
         * 加减乘除操作
         *
         * @param a a
         * @param b b
         * @return int
         */
        int operation(int a, int b);

        /**
         * 修饰符只能是default
         *
         * @param a a
         * @param b b
         * @return int
         */
        default int addition(int a, int b) {
            return a + b;
        }
    }

    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }

    /**
     * 函数式接口只能有一个抽象方法
     */
    interface GreetingService {

        /**
         * sayMessage
         *
         * @param msg String
         */
        void sayMessage(String msg);
    }
}

源于：http://www.runoob.com/java/java8-lambda-expressions.html