函数式编程及Lambda表达式详解

一.初识Lambda表达式

Lambda表达式对匿名内部类进行了优化，代码更少，关注点更明确

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("swim...普通匿名内部类");
            }
        });
        goSwimming(() -> System.out.println("swim...lambda表达式"));
    }
    public static void goSwimming(Swimming swimming){
        swimming.swim();
    }
}

interface Swimming{
    void swim();
}

二.函数式编程思想

函数式思想尽量忽略面向对象的复杂语法：强调做什么，而不是以什么形式去做，比如lambda表达式

三.Lambda表达式的格式和前提条件

1.格式：（形式参数）->{代码块}

2.形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

3.->：固定写法，代表指向动作

4.代码块：是具体要实现的事情，就是方法体内容

5.前提：

        a.必须有一个接口

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

public class TestLambda {
    public static void main(String[] args) {
        useShowHandler(()->{
            System.out.println("This is new show function");
        });
    }
    public static void useShowHandler(ShowHandler showHandler){
        showHandler.show();
    }
}
interface ShowHandler{
    void show();
}

 四.部分示例

1.接口中的唯一抽象方法是无返回值有参数的

public class StringHandlerDemo {
    public static void main(String[] args) {
        useStringHandler((s)->{
            System.out.println(s);
        });
    }
    public static void useStringHandler(StringHandler stringHandler){
        stringHandler.printMessage("sdss");
    }
}
interface StringHandler{
    void printMessage(String s);
}

2.接口中的唯一抽象方法是有返回值无参数的

public class RandomNumHandlerDemo {
    public static void main(String[] args) {
        useRandomNumHandler(()->{
            return (new Random()).nextInt(100);
        });
    }
    public static void useRandomNumHandler(RandomNumHandler randomNumHandler){
        int number = randomNumHandler.getNumber();
        System.out.println(number);
    }
}
interface RandomNumHandler{
    int getNumber();
}

3.接口中的唯一抽象方法是有返回值有参数的

public class CalculatorDemo {
    public static void main(String[] args) {
        useCalculator((i,j)->{
            return i*j;
        });
    }
    public static void useCalculator(Calculator calculator){
        double calc = calculator.calc(2.0, 3.0);
        System.out.println(calc);
    }
}
interface Calculator{
    double calc(double i,double j);
}

五.Lambda表达式的省略形式

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

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

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

public class CalculatorDemo {
    public static void main(String[] args) {
        useCalculator((i,j)-> i*j);
    }
    public static void useCalculator(Calculator calculator){
        double calc = calculator.calc(2.0, 3.0);
        System.out.println(calc);
    }
}
interface Calculator{
    double calc(double i,double j);
}

六.Lambda表达式和匿名内部类的区别

所需类型不同：1.匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

                          2.Lambda表达式：只能是接口

使用限制不同：

        1.如果接口中有且仅有一个抽象方法，Lambda表达式和匿名内部类都可以使用

        2.如果接口中多于一个抽象方法，只能使用匿名内部类

实现原理不同

        1.匿名内部类：编译之后，产生一个单独的.class字节码文件

        2.Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成