Lambda表达式语法

Lambda表达式

Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。使用 Lambda 表达式可以使代码变的更加简洁紧凑。

语法

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

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

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

示例

定义几个接口：

/*
 * 无返回值，无参数接口
 */
@FunctionalInterface
public interface LambdaNoneReturnNoneParamter {
    void test();
}

/**
 *
 * 无返回值，单个参数接口
 */
@FunctionalInterface
public interface LambdaNoneReturnSingleParameter {
    void test(int n);
}

/**
 *
 * 无返回值，多个参数解扩
 */
@FunctionalInterface
public interface LambdaNoneReturnMutipleParameter {
    void test(int a, int b);
}

/**
 *
 * 单个返回值，无参数接口
 */
@FunctionalInterface
public interface LambdaSingleReturnNoneParameter {
    int test();
}

/**
 *
 * 单返回值，单个参数接口
 */
@FunctionalInterface
public interface LambdaSingleReturnSingleParameter {
    int test(int a);
}

/**
 *
 * 单返回值，多个参数接口
 */
@FunctionalInterface
public interface LambdaSingleReturnMutipleParameter {
    int test(int a, int b);
}

下面使用Lambda表达式对上述接口实现：

package pers.zhang.syntax;

import pers.zhang.interfaces.*;

/**
 * @author zhang
 * @date 2020/1/10 - 20:54
 */
public class Syntax1 {
    public static void main(String[] args) {
        //1. Lambda表达式的语法
        //Lambda是一个匿名函数
        //(参数类别) -> {方法体}
        //（）：用来描述参数列表
        //{}：用来描述方法体
        // ->：Lambda运算符，读作goes to


        //无参数无返回
        LambdaNoneReturnNoneParamter lambda1 = () -> {
            System.out.println("hello world");
        };
        lambda1.test();


        //单个参数，无返回值
        LambdaNoneReturnSingleParameter lambda2 = (int a) -> {
            System.out.println(a);
        };
        lambda2.test(10);

        //多个参数，无返回值
        LambdaNoneReturnMutipleParameter lambda3 = (int a, int b) -> {
            System.out.println(a + b);
        };
        lambda3.test(10, 22);


        //无参数，有返回值
        LambdaSingleReturnNoneParameter lambda4 = () -> {
            System.out.println("lambda4");
            return 100;
        };
        System.out.println(lambda4.test());

        //单个参数，有返回值
        LambdaSingleReturnSingleParameter lambda5 = (int a) -> {
            return a * 2;
        };
        System.out.println(lambda5.test(25));


        //多个参数，有返回值
        LambdaSingleReturnMutipleParameter lambda6 = (int a, int b) -> {
            return a + b;
        };
        System.out.println(lambda6.test(44,55));
    }

}

精简写法：

package pers.zhang.syntax;

import pers.zhang.interfaces.LambdaNoneReturnMutipleParameter;
import pers.zhang.interfaces.LambdaNoneReturnSingleParameter;
import pers.zhang.interfaces.LambdaSingleReturnMutipleParameter;
import pers.zhang.interfaces.LambdaSingleReturnNoneParameter;

/**
 * @author zhang
 * @date 2020/1/10 - 21:24
 */
public class Syntax2 {
    public static void main(String[] args) {
        /*
            语法精简：
                1. 参数：
                    由于在接口的抽象方法中，已经定义了参数的数量和类型。所以在Lambda表达式中，参数的类型可以省略
                    注意：如果需要省略类型，则每一个参数的类型都要省略。
         */

        LambdaNoneReturnMutipleParameter lambda1 = (a, b) -> {
            System.out.println(a + b);
        };

        /*
                2. 参数小括号：
                    如果参数列表中，参数的数量只有一个。此时小括号可以省略
         */
        LambdaNoneReturnSingleParameter lambda2 = a -> {
            System.out.println("hello world");
        };

        /*
                3. 方法大括号
                    如果方法体中只有一条语句，此时大括号可以省略
         */
        LambdaNoneReturnSingleParameter lambda3 = a -> System.out.println("a = " + a);

        /*
                4.如果方法体中唯一的一条语句是一个返回语句，则在省略掉大括号的同时，也必须省略掉return.
         */
        LambdaSingleReturnNoneParameter lambda4 = () -> 10;


        LambdaSingleReturnMutipleParameter lambda5 = (a, b) -> a + b;
        System.out.println(lambda5.test(10, 20));
    }
}