Lambda

Lambda表达式

Lambda 表达式，也可称为闭包
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）
使用 Lambda 表达式可以使代码变的更加简洁紧凑

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

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

重要特征

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

---

代码展示

/*
    游泳接口
 */
interface Swimming {
    void swim();
}

public class TestSwimming {
    public static void main(String[] args) {
        // 通过匿名内部类实现
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });

        /*  通过Lambda表达式实现
            理解: 对于Lambda表达式, 对匿名内部类进行了优化
         */
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

函数式编程思想概述
在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”
面向对象思想强调“必须通过对象的形式来做事情”
函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现

Lambda表达式的标准格式
格式：
(形式参数) -> {代码块} (组成Lambda表达式的三要素)
形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
->：由英文中画线和大于符号组成，固定写法。代表指向动作
代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

Lambda表达式的使用前提

• 使用Lambda必须要有接口
• 并且要求接口中有且仅有一个抽象方法

代码展示：
无参无返回值抽象方法的练习

//无参无返回值抽象方法的练习
//接口
public interface Eatable {
   void eat();
}
//实现类
public class EatableImpl implements Eatable {
   @Override
   public void eat() {
       System.out.println("一天一苹果，医生远离我");
   }
}
//测试类
public class EatableDemo {
   public static void main(String[] args) {
       //在主方法中调用useEatable方法
       Eatable e = new EatableImpl();
       useEatable(e);

       //匿名内部类
       useEatable(new Eatable() {
           @Override
           public void eat() {
               System.out.println("一天一苹果，医生远离我");
           }
       });

       //Lambda表达式
       useEatable(() -> {
           System.out.println("一天一苹果，医生远离我");
       });
   }

   private static void useEatable(Eatable e) {
       e.eat();
   }
}

---

有参无返回值抽象方法的练习

//有参无返回值抽象方法的练习
public interface Flyable {
    void fly(String s);
}

public class FlyableDemo {
    public static void main(String[] args) {
        //在主方法中调用useFlyable方法
        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飞机自驾游");
            }
        });
        System.out.println("--------");

        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游");
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }
}

---

有参有返回值抽象方法的练习

//有参有返回值抽象方法的练习
public interface Addable {
    int add(int x,int y);
}

public class AddableDemo {
    public static void main(String[] args) {
        //在主方法中调用useAddable方法
        useAddable((int x,int y) -> {
            return x + y;
        });

    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

---

Lambda表达式的省略模式
省略的规则:

• 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
• 如果参数有且仅有一个，那么小括号可以省略
• 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

代码展示

public interface Addable {
    int add(int x, int y);
}

public interface Flyable {
    void fly(String s);
}

public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x,int y) -> {
//            return x + y;
//        });
        //参数的类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

    private static void useFlyable(Flyable f) {
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

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

所需类型不同

• 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
• Lambda表达式：只能是接口

使用限制不同

• 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
• 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

实现原理不同

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