Lambda 表达式

声明：java8新特性系列为个人学习笔记，参考地址点击这里，侵删！！

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

为什么使用 Lambda 表达式

Lambda 是一个 匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。

从匿名类到 Lambda 的转换举例

// 匿名内部类
Runnable runnable = new Runnable() {
    @Override
    public void run() {
        System.out.println("hello lambda");
    }
};
// Lambda表达式
Runnable runnable1 =()->System.out.println("hello lambda");

语法

Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ，该操作符被称为 Lambda 操作符或 箭头操作符。它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的参数列表

右侧：指定了 Lambda 体，是抽象方法的实现逻辑，也即Lambda 表达式要执行的功能。

lambda 表达式的语法格式如下：

(parameters) -> expression
(parameters) -> { statements; }

以下是lambda表达式的重要特征:

可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

Lambda 表达式实例

Lambda 表达式的简单例子:

// 语法格式一：无参，无返回值
Runnable r1 = () -> System.out.println("hello Lambda");

//语法格式二：Lambda 需要一个参数，但是没有返回值。
Consumer<String> consumer = (String s) -> System.out.println(s);

//语法格式三：数据类型可以省略 ，因为可由编译器推断得出，称为“类型推断”
Consumer<String> consumer1 = (s) -> System.out.println(s);

//语法格式四：Lambda 若只需要一个参数时，参数的小括号可以省略
Consumer<String> consumer2 = s -> System.out.println(s);

// 语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值
Comparator<Integer> comparator = (x, y) -> {
System.out.println("实现函数接口方法！");
return Integer.compare(x, y);
};

// 语法格式六 : 当Lambda体只有一条语句时，return与大括号都可以省略
Comparator<Integer> comparator1 = (x, y) -> Integer.compare(x, y);

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的“类型推断”。

示例代码

在 LambdaTester.java 文件输入以下代码：

package lambda;

/**
 * Lambda表达式 测试类
 *
 * @author shensr
 * @version V1.0
 * @create 2019/10/24
 **/

public class LambdaTester {
    public static void main(String[] args) {
        LambdaTester tester = new LambdaTester();

        // 类型声明
        MathOperation addition = (int a, int b) -> a + b;

        // 不用类型声明
        MathOperation subtraction = (a, b) -> a - b;

        // 大括号和返回语句同时存在
        MathOperation multiplication = (a, b) -> {
            return a * b;
        };

        // 没有大括号及返回语句
        MathOperation division = (a, b) -> a / b;

        System.out.println("10 + 5 = " + tester.operate(10, 5, addition));
        System.out.println("10 - 5 = " + tester.operate(10, 5, subtraction));
        System.out.println("10 x 5 = " + tester.operate(10, 5, multiplication));
        System.out.println("10 / 5 = " + tester.operate(10, 5, division));

        // 参数不加括号
        GreetingService greetService1 = message ->
                System.out.println("Hello " + message);

        // 参数加括号
        GreetingService greetService2 = (message) ->
                System.out.println("Hello " + message);

        greetService1.sayMessage("BaiDu");
        greetService2.sayMessage("Google");
    }

    @FunctionalInterface
    interface MathOperation {
        /**
         * 对a和b进行数学运算
         *
         * @param a 操作数a
         * @param b 操作数b
         * @return 经过数学运算之后的结果
         */
        int operation(int a, int b);
    }

    interface GreetingService {
        /**
         * 输出消息
         *
         * @param message 传入消息
         */
        void sayMessage(String message);
    }

    /**
     * 计算
     *
     * @param a             操作数a
     * @param b             操作数b
     * @param mathOperation 函数式接口
     * @return 返回计算结果
     */
    private int operate(int a, int b, MathOperation mathOperation) {
        return mathOperation.operation(a, b);
    }
}

执行以上脚本，输出结果为：

10 + 5 = 15
10 - 5 = 5
10 x 5 = 50
10 / 5 = 2
Hello BaiDu
Hello Google

使用 Lambda 表达式需要注意以下两点：

Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。在上面例子中，我们使用各种类型的Lambda表达式来定义MathOperation接口的方法。然后我们定义了sayMessage的执行。
Lambda 表达式免去了使用匿名方法的麻烦，并且给予Java简单但是强大的函数化的编程能力。

变量作用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误。java 8 放松了这个限制，可以使用非final变量，但是该变量在既成事实上必须是final，即不能再次给该变量复制，否则编译错误。

在 ScopeOfVariable.java 文件输入以下代码：

package lambda;

import java.util.Comparator;

/**
 * <p>
 * description: lambda 表达式只能引用标记了 final 的外层局部变量，
 * 这就是说不能在 lambda 内部修改定义在域外的局部变量，否则会编译错误;
 * java 8 放松了这个限制，可以使用非final变量，但是该变量在既成事实上必须是final，即不能再次给该变量复制，否则编译错误；
 * </p>
 *
 * @author shensr
 * @version V1.0
 * @create 2019/10/24
 **/

public class ScopeOfVariable {

    public static void main(String[] args) {
        // 引用标记了 final 的外层局部变量
        final String msg = "scope of variable";
        Runnable runnable = () -> System.out.println("hello" + msg);
        // 引用非final 的外层局部变量
        String msg1 = "scope of variable";
        Runnable runnable1 = () -> System.out.println("hello" + msg1);

        // 引用非final 的外层局部变量，再次修改msg2的值，就会编译出错
        String msg2 = "scope of variable";
        msg2 = "update msg2";
        Runnable runnable2 = () -> System.out.println("hello" + msg2); //编译会出错
        // 在 Lambda 表达式当中不允许声明一个与局部变量同名的参数或者局部变量。
        String first = "";
        Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  //编译会出错
    }


}