函数式编程思想概述

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

而Lambda表达式就是函数式思想的体现

lambda 表达式（闭包）

基本概念

Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。

使用 Lambda 表达式可以使代码变的更加简洁紧凑。

格式

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

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

省略模式

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

组成Lambda表达式的三要素

形式参数，箭头，代码块

Lambda 表达式练习

无参无返回值抽象方法

定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
定义一个测试类(EatableDemo)，在测试类中提供两个方法
- 一个方法是：useEatable(Eatable e)
- 一个方法是主方法，在主方法中调用useEatable方法

//接口
public interface Eatable {
    void eat();
}

//实现类
public class EatableIml implements Eatable{

    @Override
    public void eat() {
        System.out.println("666666");
    }
}

//测试类
public class EatableDemo {
    public static void main(String[] args) {
        //主方法调用
        Eatable e=new EatableIml();
        useEatable(e);
        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("666666");
            }
        });
        //Lambda表达式
        useEatable(()->{
            System.out.println("666666");
        });

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

有参无返回值抽象方法

定义一个接口(Flyable)，里面定义一个抽象方法：void fly(String s);
定义一个测试类(FlyableDemo)，在测试类中提供两个方法
- 一个方法是：useFlyable(Flyable f)
- 一个方法是主方法，在主方法中调用useFlyable方法

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("风和日丽，晴空万里");
    }
}

有参有返回值抽象方法

定义一个接口(Addable)，里面定义一个抽象方法：int add(int x,int y);
定义一个测试类(AddableDemo)，在测试类中提供两个方法
- 一个方法是：useAddable(Addable a)
- 一个方法是主方法，在主方法中调用useAddable方法

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 表达式的注意事项

使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
必须有上下文环境，才能推导出Lambda对应的接口
- 根据局部变量的赋值得知Lambda对应的接口
  
  Runnable r = () -> System.out.println("Lambda表达式");
- 根据调用方法的参数得知Lambda对应的接口
  
  new Thread(() -> System.out.println("Lambda表达式")).start();

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

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

补充：

Lambda表达式是延迟执行的，有些场景的代码执行后，结果不一定会被使用，从而造成性能浪费，可作为解决方案，提升性能。

方法引用

出现原因

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿什么参数做什么操作。那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑？答案肯定是没有必要，那我们又是如何使用已经存在的方案的呢？使用方法引用。

方法引用符

:: 该符号为引用运算符，而它所在的表达式被称为方法引用

推导与省略

- 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
- 如果使用方法引用，也是同样可以根据上下文进行推导
- 方法引用是Lambda的孪生兄弟

示例-引用类方法

public interface Converter {
    int conver(String s);
}public class ConverterDemo {
    public static void main(String[] args) {
        // lambda表达式 引用类方法  类名.方法名，
        // 传递的参数类型可省略，return也可以，中括号也可省略
        // 因为我们使用该方法的目的是将参数的类型进行转化
        // 再Integer对象有个方法是可以将字符串传化为int
        // 而且我们使用该方法的参数类型就是int
        // 我们只需要返回一个int对象就可以了，
        // 就可以直接使用调用Integer类.parseInt方法，return一个int类型的变量
        useConverter((s)-> Integer.parseInt(s));
        // 方法引用，道理也是相同，我们不用管参数类型
        // 因为当使用方法引用时，
        // lambda表达式中的参数会直接给到引用的静态方法作为参数
        // Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
        useConverter(Integer::parseInt);
    }

    private static void useConverter(Converter c) {
        int num = c.conver("8888");
        System.out.println(num);
    }
}

示例-引用对象的实例方法

public interface Printer {
    void  printUpperCase(String s);
}

public class PrintString {
    public void printUpper(String s){
        String result = s.toUpperCase();
        System.out.println(result);
    }
}

public class PrinterDemo {
    public static void main(String[] args) {
        // lambda表达式，获取参数。调用String类下toUpperCase方法
        // toUpperCase方法将此String所有字符转换为大写
        usePrinter((s)->{
            System.out.println(s.toUpperCase());
        });
        // 方法引用，调用类中成员方法
        // 创建类对象，使用该类下的成员方法printUpper

        // Lambda表达式被对象的实例方法替代的时候，
        // 它的形式参数全部传递给该方法作为参数
        PrintString printString = new PrintString();
        usePrinter(printString::printUpper);
    }

    private static void usePrinter(Printer p) {
        p.printUpperCase("dgwgwgehegwee");
    }
}

示例-引用类的实例方法

public interface MyString {
    String myString(String s,int x,int y);
}

public class MyStringDemo {
    public static void main(String[] args) {
        // lambda表达式，返回一个字符串对象，对字符串操作截取，substring方法
        useMyString((s,x,y)->s.substring(5,7));
        useMyString((s,x,y)->s.substring(5,8));
        // 方法引用，Lambda表达式被类的实例方法，替代时，第一个参数作为调用者，剩余参数作为该方法的参数
        // 方法引用就是对lambda表达式方案的重复调
        // 用已经存在的方案
        useMyString(String::substring);
    }
    private static void useMyString(MyString my){
        String s =my.myString("ghhdhdhvdsvsvs",5,7);
        System.out.println(s);
    }
}

示例-引用构造器

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

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public interface StudentBuilder {
    Student build(String name,int age);
}

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

        //Lambda简化写法
        useStudentBuilder((name,age) -> new Student(name,age));

        //引用构造器
        useStudentBuilder(Student::new);

    }

    private static void useStudentBuilder(StudentBuilder sb) {
        Student s = sb.build("林青霞", 30);
        System.out.println(s.getName() + "," + s.getAge());
    }
}

基础知识复习 （十二）Lambda表达式和方法引用