Java中的Lambda表达式

lambda表达式是一个可传递的代码块，可以在以后执行一次或多次。

1.lambda表达式的语法

eg：有如下lambda表达式：

(int a, int b) -> {return a+b};

这个表达式的本质是一个函数。

一般的函数类似如下：

int add(int a, int b) {
    return a+b;
}

有返回值、方法名、参数列表、方法体。

而Lambda表达式只有参数列表和方法体：

(参数列表)->{方法体}

说明：

• () ：用来描述参数列表；

• {} ：用来描述方法体；

• -> ：Lambda运算符可以叫做箭头符号，或者 goes to（指向）；

2.函数式接口

对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式。这种接口叫做函数式接口。

通过使用lambda表达式展示应用场景。

public class Lambda {
    public static void main(String[] args) {
        If1 if1 = ()->{
            System.out.println("无参无返回值");
        };
        //调用方法
        if1.test();

        If2 if2 = (int a)->{
            System.out.println("单个参数无返回值：a = " + a);
        };
        if2.test(2);

        If3 if3 = (int a, int b)->{
            System.out.println("两个参数无返回值：a + b = " + (a + b));
        };
        if3.test(1, 2);

        If4 if4 = ()->{
          return 4;
        };
        System.out.println("无参有返回值，返回值为：" + if4.test());

        If5 if5 = (int a)->{
          return a;
        };
        System.out.println("有参有返回值，返回值为：a = " + if5.test(5));

    }

    //无参无返回值
    interface If1 {
        void test();
    }
    //单个参数无返回值
    interface If2{
        void test(int a);
    }
    //两个参数无返回值
    interface If3{
        void test(int a, int b);
    }
    //无参有返回值
    interface If4{
        int test();
    }
    //有参有返回值
    interface If5{
        int test(int a);
    }
}

运行结果如图：

关于如下代码的问题：

        If1 if1 = ()->{
            System.out.println("无参无返回值");
        };
        //调用方法
        if1.test();

在上述代码中，If1不是一个接口吗？为什么能够有对象if1呢？

实际上这里是使用了lambda来实现匿名内部类的作用，如下：

        If1 if1 = new If1() {
            @Override
            public void test() {
                System.out.println("无参无返回值");
            }
        };
        //调用方法
        if1.test();

而匿名内部类写成正常的实现类就是类实现If1接口然后创建if1类对象，代码如下：

//定义接口
interface If1{
    void test();
}
//实现了接口的类
class NiMing implements If1{
    void test() {
            System.out.println("无参数无返回值")；
    }
}
//创建类对象
public class Test{
    NiMing if1 = new NiMing();
}

3.lambda表达式精简语法

• 参数类型可以省略

• 假如只有一个参数，()括号可以省略

• 如果方法体只有一条语句，{}大括号可以省略

• 如果方法体中唯一一条语句是return返回语句，那么省略大括号的同时return也要省略（只省略return，不省略整个return语句）

  实例代码如下：

public class Lambda2 {
    public static void main(String[] args) {
        //无参数()括号不能省略
        If1 if1 = ()->{
            System.out.println("无参无返回值");
        };
        //调用方法
        if1.test();

        //单个参数，参数类型和()括号可以省略
        //方法体内单个语句{}大括号可以省略
        If2 if2 = a-> System.out.println("单个参数无返回值：a = " + a);
        if2.test(2);

        If3 if3 = (a, b)-> System.out.println("两个参数无返回值：a + b = " + (a + b));
        if3.test(1, 2);

        //省略return和{}大括号
        If4 if4 = ()->4;
        System.out.println("无参有返回值，返回值为：" + if4.test());

        If5 if5 = a->a;
        System.out.println("有参有返回值，返回值为：a = " + if5.test(5));

    }

    //无参无返回值
    interface If1 {
        void test();
    }
    //单个参数无返回值
    interface If2{
        void test(int a);
    }
    //两个参数无返回值
    interface If3{
        void test(int a, int b);
    }
    //无参有返回值
    interface If4{
        int test();
    }
    //有参有返回值
    interface If5{
        int test(int a);
    }
}

运行结果如下：

4.方法引用

有时候多个lambda表达式实现的函数是一样的话，可以封装成通用方法，以便于维护；

这个时候可以用方法引用实现：

语法是：对象::方法

假如是static静态方法，可以直接 类名::方法

4.1非静态方法的方法引用

示例代码如下：

public class Lambda3 {
    public static void main(String[] args) {
        If if1 = a -> a-2;
        System.out.println("if1的返回值为： " + if1.test(3));

        If if2 = a -> a-2;
        System.out.println("if2的返回值为： " + if2.test(4));
    }

    //单个参数有返回值
    interface If{
        int test(int a);
    }
}

可以看到两个对象调用的是同一种方法，所以可以使用方法引用来替代，代码如下：

public class Lambda3 {
    public static void main(String[] args) {
//        If if1 = a -> a-2;
//        System.out.println("if1的返回值为： " + if1.test(3));
//
//        If if2 = a -> a-2;
//        System.out.println("if2的返回值为： " + if2.test(4));
        //创建对象
        Lambda3 lambda3 = new Lambda3();

        //利用lambda表达式引用方法
        If if1 = lambda3::testA;
        System.out.println("if1的返回值为： " + if1.test(3));

        If if2 = lambda3::testA;
        System.out.println("if2的返回值为： " + if2.test(4));
    }

    public int testA(int a) {
        return a-2;
    }

    //单个参数有返回值
    interface If{
        int test(int a);
    }
}

实际上testA实现的也是接口If中的方法。

4.2静态方法的方法引用

直接使用 类名::方法

public class Lambda4 {
    public static void main(String[] args) {

        //利用lambda表达式引用方法
        If if1 = Lambda4::testA;
        System.out.println("if1的返回值为： " + if1.test(3));

        If if2 = Lambda4::testA;
        System.out.println("if2的返回值为： " + if2.test(4));

    }
    //静态方法
    public static int testA(int a) {
        return a-2;
    }

    //单个参数有返回值
    interface If{
        int test(int a);
    }
}

5.构造方法引用

如果函数式接口的实现恰好可以通过调用一个类的构造方法来实现，那么就可以使用构造方法引用。

语法： 类名::new

实例代码如下：

首先定义一个Dog类：

public class Dog {
    private String name;
    private int age;

    //无参构造方法
    public Dog(){}
    //有参构造方法
    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return this.name;
    }

    public int getAge() {
        return this.age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
//重写toString方法
    public String toString() {
        return "Dog{" + "name='" + name + '\'' +
                ", age=" + age + '}';
    }
}

然后测试构造方法引用：

public class Lambda5 {
    public static void main(String[] args) {
//        //传统方法
//        //无参
//        DogService1 dog1 = () -> {
//          return new Dog();
//        };
//        System.out.println(dog1.getDog());
//        //简化版本
//        DogService1 dog1 = () -> new Dog();
//        System.out.println(dog1.getDog());
        //构造方法引用
        //无参
        DogService1 dog1 = Dog::new;
        System.out.println(dog1.getDog());

        //有参
        DogService2 dog2 = Dog::new;
        System.out.println(dog2.getDog("小汪", 1));
    }

    interface DogService1{
        Dog getDog();   //无参
    }

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