Java之Lambda表达式

Lambda表达式

Lambda表达式是对匿名内部类进行优化，但是二者有本质区别。

package com.test;

public class LambdaDemo {

    public static void main(String[] args) {

        /*
        匿名内部类写法
         */
        goSwiming(new Swiming() {
            @Override
            public void swim() {
                System.out.println("go swiming...");
            }
        });

        /*
        Lambda表达式写法是对匿名内部类进行了优化
         */
        goSwiming(() -> {
            System.out.println("go swiming...");
        });
    }

    public static void goSwiming(Swiming swiming) {
        swiming.swim();
    }

}

面向对象思想：强调“通过对象的形式去做事情”。更多关注怎么去做，谁（哪个对象）去做？

函数式编程思想：尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”。更多关注做什么？Lambda表达式就是函数式思想的体现。

Lambda表达式的标准格式

组成Lambda表达式的三要素：形式参数、箭头、代码块

Lambda表达式的格式：

​ 格式：(形式参数)->{代码块}

​ ->：由英文画线和大于符号组成，固定写法。代表指向动作

​ 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

Lambda表达式的使用前提：

​ 有一个接口。（侧面反映：只能操作接口不能操作类）。

​ 接口中有且仅有一个抽象方法

Lambda小练习1（抽象方法无参无返回值）

package com.lambda;

public class TestLambda {

    /*
    Lambda表达式的使用前提：
        1.一个接口
        2.接口中有且仅有一个抽象方法（show），该方法是无参数无返回值
        3.在测试类（TestLambda）中存在一个方法（useShowHandler）
            方法的参数是ShowHandler类型的
            在方法内部调用ShowHandler的show方法
   练习：
    1.编写一个接口（ShowHandler）
    2.在该接口中存在一个抽象方法（）
     */
    public static void main(String[] args) {
        //匿名内部类写法
        useShowHandler(new ShowHandler() {
            @Override
            public void show() {
                System.out.println("匿名内部类中的show方法");
            }
        });

        //Lambda式写法
        useShowHandler(() -> {
            System.out.println("Lambda中的show方法");
        });

        //Lambda简化写法
        useShowHandler(() ->
                System.out.println("Lambda简化写法中的show方法")
        );
    }

    //main方法是静态的，静态可以使用静态不能使用非静态的
    public static void useShowHandler(ShowHandler showHandler) {
        showHandler.show();
    }

}

interface ShowHandler {
    public void show();
}

Lambda小练习2（抽象方法有参数无返回值）

package com.lambda;

public class TestLambda2 {

    /*
    1.首先存在一个接口（StringHandler）
    2.在该接口中存在一个抽象方法（printMessage），该方法有参数无返回值
    3.在测试类（TestLambda2）中存在一个方法（useStringHandler），方法的参数是StringHandler类型的，在方法内部调用了StringHandler的printMessage方法
     */
    public static void main(String[] args) {

        //匿名内部类写法
        useStringHandler(new StringHandler() {
            @Override
            public void printMessage(String msg) {
                System.out.println("匿名内部类" + msg);
            }
        });

        //Lambda式写法
        useStringHandler((String msg) -> {
            System.out.println("Lambda写法" + msg);
        });

        //Lambda简化写法
        useStringHandler(msg ->
                System.out.println("Lambda简化写法" + msg)
        );
    }

    public static void useStringHandler(StringHandler stringHandler) {
        stringHandler.printMessage("Lambda");
    }

}

interface StringHandler {
    void printMessage(String msg);
}

Lambda小练习3（抽象方法无参有返回值）

package com.lambda;

import java.util.Random;

public class TestLambda3 {

     /*
        1.首先存在一个接口（RandomNumHandler）
        2.在该接口中存在一个抽象方法（getNumber），该方法无参数但是有返回值
        3.在测试类（TestLambda3）中存在一个方法（useRandomNumHandler），方法的参数是RandomNumHandler类型的，在方法内部调用了RandomNumHandler的getNumber方法
     */

    public static void main(String[] args) {

        //匿名内部类写法
        getNumber(new RandomNumHandler() {
            @Override
            public int getNumber() {
                Random r = new Random();
                int result = r.nextInt(10) + 1;
                return result;
            }
        });

        //注意：如果Lambda所操作的接口中的方法有返回值，一定要通过return语句，将结果返回，否则会出现编译错误
        //Lambda写法
        getNumber(() -> {
            Random r = new Random();
            int result = r.nextInt(10) + 1;
            return result;
        });
        
    }

    public static void getNumber(RandomNumHandler randomNumHandler) {
        int result = randomNumHandler.getNumber();
        System.out.println("result = " + result);
    }

}

interface RandomNumHandler {
    int getNumber();
}

Lambda小练习4（抽象方法有参有返回）

package com.lambda;

public class TestLambda4 {

    /*
        1.首先存在一个接口（Calculator）
        2.在该接口中存在一个抽象方法（calc），该方法有参数也有返回值
        3.在测试类（TestLambda4）中存在一个方法（useCalculator），方法的参数是Calculator类型的，在方法内部调用了Calculator的calc方法
     */

    public static void main(String[] args) {

        //匿名内部类写法
        useCalculator(new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a + b;
            }
        });

        //Lambda写法
        useCalculator((int a, int b) -> {
            return a + b;
        });

        //Lambda简化写法
        useCalculator((a, b) ->
                a + b
        );

    }

    public static void useCalculator(Calculator calculator) {
        int result = calculator.calc(1, 2);
        System.out.println("result = " + result);
    }

}

interface Calculator {
    int calc(int a, int b);
}

Lambda表达式的省略模式

省略规则：

​ 参数类型可以省略，但是有多个参数的情况下，不能只省略一个

​ 如果参数有且仅有一个，那么小括号可以省略

​ 如果代码块的语句只有一条，可以省略大括号和分号，甚至是return

Lambda表达式和匿名内部类的区别对比

所需类型不同
匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
Lambda表达式：只能是接口
使用限制不同
如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
实现原理不同
匿名内部类：编译之后，产生一个单独的.class字节码文件
Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成（在内存中，不会保留在硬盘中）

举例：

package com.lambda;

public class TestLambda05 {

    public static void main(String[] args) {
        useShow(() -> System.out.println("inter..."));

        useShow(new Inter() {
            @Override
            public void show() {
                System.out.println("show...");
            }
        });

    }

    public static void useShow(Inter inter) {
        inter.show();
    }

}

interface Inter {
    void show();
}