Lambda 表达式

简介

　　相传，在远古时代，有一位逻辑学家某某，想要形式化的表示能有效计算的数学函数，由于别的书中使用重音符^来表示自由变量，某某受此启发，使用大写的lambda（∧）表示参数，后来又改成了小写的lambda（λ），从此以后，带参数变量的表达式就被称为lambda表达式，读音：lan b（m）da （兰亩达）。

　　到了2015年，lambda表达式加入了JDK8，它显著的增强了Java，在最近几年中，lambda表达式已经成为了计算机语言设计的重点关注对象，几年前的泛型重塑了Java，如今lambda表达式也正在重塑Java的编程风格。

　　简而言之：lambda表达式，无论如何，就算天崩地裂，得了绝症，也得学！

　　言归正传

　　lambda表达式本质上就是一个匿名方法，但是这个方法不是独立执行的，而是用于实现由函数式接口定义的另一个方法，因此lambda表达式会导致产生一个匿名类，也可以称之为闭包。

语法结构

　　lambda表达式在Java语言中引入了一个新的语法元素和操作符，这个操作符是->，有时候被称为lambda操作符或者箭头操作符，它将lambda表达式分成两个部分，左侧指定了lambda表达式需要的所有参数（不需要参数则使用空括号），右侧是表达式的主体。

　　下面看一个最简单的lambda表达式：

　　()-> 12;

这个lambda表达式没有参数，但是它有返回值，返回的是Int类型。

　　如果代码要完成的功能无法放在一个表达式中，就可以像写方法一样，把代码放在代码块中，用大括号包起来。

　　()->{
        for(int i=0;i<10;i++){
            System.out.println(i);
        }
    }

这个lambda没有返回值，也可以说它的返回值是void,如果有返回值的话，需要在表达式主体的最后使用return关键字返回指定类型的数据。

　　下面来看一个有参数的lambda表达式

　　(int n,int m)->n+m;

参数为int，返回值也是int类型。

　　不过一般来说我们这么写：

　　(n,m)->n+m;

　　如果只有一个入参，你甚至连括号都可以省：

　　n -> n+1;

省略了参数类型，因为参数类型是可以被自动推断出来的。

函数式接口

　　函数式接口是仅包含一个抽象方法的接口，可以反过来这么说，凡是只包含一个抽象方法的接口，都可以叫做函数式接口。

　　为什么要说函数式接口呢？因为lambda表达式的运行需要依赖函数式接口。

　　从JDK8开始，可以为接口的声明的方法指定默认行为，就是所谓的默认方法（在接口中用default关键字声明的方法，并且可以在接口中直接实现该方法，使得实现该接口的类不需要实现该方法，就如继承一样直接调用），因为该默认方法没有指定默认实现，所以它就是隐式的是抽象方法，没有必要使用abstract修饰符，当然，如果愿意的话，也可以加上abstract修饰符。

示例：

　　public interface Admin {
           String getName();
    }

随便写的一个接口，只要这个接口中只有一个抽象方法，那么这就是一个函数式接口。（注意措辞：只有一个抽象方法，并不是只有一个方法，因为还可以存在默认方法）

　　lambda表达式允许你直接以内联的形式为函数式接口的抽象方法提供实现，也就是说，lambda表达式构成了一个函数式接口定义的抽象方法的实现，该函数式接口定义了它的目标类型。

下面示例lambda表达式的使用方法（使用到上面的Admin接口）：

        Admin admin = ()->"张三";
        System.out.println(admin.getName());

打印结果为：张三

　　当目标类型上下文出现lambda表达式时，会自动创建实现了该函数式接口的一个类的实例，函数式接口声明的抽象方法的行为由lambda表达式定义，当通过目标调用该方法时，就会执行lambda表达式，因此，lambda表达式提供了一种将代码片段转换为对象的方法。

　　也就是说，也就是说，也就是说，重要的事情说三遍：如果我写一个方法，参数是Admin类型，那么我可以调用这个方法直接传入lambda表达式即可，为什么连说三遍呢？因为这是最流行的用法，也是lambda的风骚之处：传递行为。

比如：

    private static void myName(Admin admin){
        String name = admin.getName();
        System.out.println(name);
    }

然后我可以这么调用：myName(()->"张三");

　　但是本篇博客剩下的例子几乎不会这样子写，是因为代码多了不易让人理解，因此尽量写的直接一些。

　　当然，老土的办法是用内部类来实现：

        Admin admin = new Admin() {
            @Override
            public String getName() {
                return "张三";
            }
        };
        System.out.println(admin.getName());

类型检查与类型推断

　　为什么下面这个代码不能编译呢？

　　Object o = () -> System.out.println("张三");

　　因为lambda表达式上下文的目标类型必须是一个函数式接口，而Object并不是函数式接口

　　我下面这个接口是函数式接口

public interface User {
    String userInfo(String name,int age);
}

　　那么我这样子可以吗？

　　User user = () -> System.out.println("张三");

也是不行的，因为User接口的抽象方法是有入参也有返回值的，但是() -> System.out.println("张三")却是一个没有入参也没有返回值的表达式。

　　所以说lambda表达式的入参和返回值必须要和函数式接口兼容。

　　User函数式接口的入参是String和int，返回值是String，正确的用法应该是这样的：

        String name = "小红";
        int age = 19;
        User user = (String username,int userage) -> {
            return username+"今年"+userage+"岁了";
        };
        System.out.println(user.userInfo(name,age));　　

可以更简洁一点吗？ 可以的。

　　Java编译器会从上下文来推断出用什么函数式接口来配合lambda表达式，它也可以推断出适合lambda表达式的签名。

　　就像我们经常使用的菱形运算符一样：

        HashMap<String,Integer> map1 = new HashMap<String,Integer>();
        HashMap<String,Integer> map2 = new HashMap<>();

　　因此省略参数类型也是可以的：

        User user = (username,userage) -> {
            return username+"今年"+userage+"岁了";
        };

　　有时候写明参数类型更易读，有时候省略参数类型更易读，这个就是仁者见仁智者见智了。

还可以再简洁一点吗？当然可以。

　　注意这个lambda表达式的主体，并不是什么复杂的计算流程，它仅仅只是一个普通的表达式。

　　所以可以不用块表达式：

　　User<String> user2 = (username,userage) -> username+"今年"+userage+"岁了";

　　就这样一行代码就完事，自带隐式的return。

泛型函数式接口

　　lambda表达式的类型推断是相当的智能，不过，如果我写这么个函数式接口，泛型，试一试它还能不能智能的起来？

public interface MyUser<T> {
    String userInfo(String name,T age);
}

　　显然不可能，编译都过不了，因为它已经懵逼了，不知道你的参数到底是个什么类型。

　　这时候，就需要在lambda表达式的目标类型上指定参数类型：

        String name = "小芳";
        int age1 = 17;
        double age2 = 17.5;

        MyUser<Integer> myUser = (n,a) -> n+a;
        String str1 = myUser.userInfo(name,age1);
        System.out.println(str1);

        MyUser<Double> myUser1 = (n,a) -> n+a;
        String str2 = myUser1.userInfo(name,age2);
        System.out.println(str2);

引用值，而不是变量

　　我们目前为止在lambda表达式主体中使用的变量都是传进来的参数，在lambda表达式中，可以访问外层作用域定义的变量，将其引用为当前表达式内的局部变量，这叫做变量捕获。

　　在这种情况下，lambda表达式只能使用final的局部变量，也就是说，被lambda表达式捕获的外层变量，都会自动变成实质上的final类型，final变量是指在第一次赋值以后，值不能再发生变化的变量。

示例：

        String name = "小红";
        int age = 22;
        int status = 1;
        User user = (n,a) -> {
            //status ++; //不允许
            return n+a+"状态是"+status;
        };
        //status ++; //不允许
        String str = user.userInfo(name,age);
        System.out.println(str);

示例中的status变量被lambda表达式捕获之后，在lambda表达式中不能修改，在外层也不能被修改，

　　实际上lambda在访问外层变量时，访问的是变量的副本，并不是原始变量。

　　换句话说，lambda表达式引用的是值，而不是变量。

方法引用

深入剖析方法引用

　　方法引用的基本思想是：如果一个lambda表达式代表的只是直接调用这个方法，那么最好还是用名称来调用它，而不是去描述如何调用它。

　　方法引用提供了一种引用而不执行的方式，这种特性与lambda表达式相关，因为它也需要由兼容的函数式接口构成的目标类型上下文，运行的时候，方法引用也会创建函数式接口的一个实例。

　　当你需要使用方法引用时，目标引用放在分隔符::前，方法名称放在后面，例如User::getName就是引用了User类中的getName()方法，请记住，不需要括号,因为你没有实际调用这个方法，它其实就是(User a)->a.getName()的快捷写法。

下面走一个例子：

　　函数式接口

public interface User {
    String userInfo(String name,int age);
}

　　处理用户信息的类

public class MyInfo {
    static String name(String name,int age){
        if(age < 18){
            name = "少年人"+name;
        }else if(age > 18 && age< 28){
            name = "青年人"+name;
        }else{
            name = "老年人"+name;
        }
        return name+"年龄是"+age;
    }
}

　　接口调用方法

    public static String userThink(User user,String name,int age){
        return user.userInfo(name,age);
    }

　　主函数

    public static void main(String[] args) {
        String name = "小明";
        int age = 15;
        String outStr = userThink(MyInfo::name,name,age);
        System.out.println(outStr);
    }

　　观察可以得知 MyInfo::name进入userThink方法之后变成了User接口的一个实例，MyInfo类的name方法需要两个参数，而引用的时候并没有传参，因此更加证实了方法引用并非方法调用。

　　如果我这么改一下 你可能会恍然大悟：

        User user = MyInfo::name;
        String info = user.userInfo(name,age);
        System.out.println(info);

　　原来引用的方法就是lambda表达式的主体，牢记这一点非常重要。

　　因此我们这么下结论：如果lambda表达式的主体内容是调用一个方法，那么就可以使用方法引用，当然，引用的方法必须与上下文所使用的函数式接口相兼容。

下面介绍几种方法引用的例子：

lambda表达式	等效的方法引用
() -> Thread.currentThread().dumpStack()	Thread.currentThread()::dumpStack
(str,i) -> str.substring(i)	String::substring
(String s) -> System.out.println(s)	System.out::println

　　本节示例MyInfo中的name方法是一个静态方法，如果不是静态方法呢？

　　不是静态方法的话，那么就需要将整个类new出来，再进行该对象的方法引用。

　　还有一种情况，就如上面表格中的(str,i) -> str.substring(i)为什么可以用方法引用String::substring来替代呢？ 

　　substring是静态方法吗？ 不是的。

　　String类有new出来吗？ 也没有。

　　原因只有一个：String实例是传入lambda表达式的参数，因此str本身就是String的实例，拥有String的所有方法。

　　如果你要引用一个对象的方法，而这个对象本身是lambda的一个参数，那么Java允许你直接引用。

构造函数引用

　　构造器引用与方法引用是一样的，只不过方法名固定为new，例如：Admin::new是Admin构造器的一个引用，它就相当于 () -> new Admin()，注意，也就是说当前使用的函数式接口的返回类型必须兼容Admin。

下面走一个示例（写示例是最头疼的事情了 汗）：

　　一个学生类

public class Student {
    String name;
    int grade = 0;

    public Student(String name) {
        this.name = name;
    }
    
    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }
    public String getName() {
        return name;
    }
    public int getGrade() {
        return grade;
    }
}

　　函数式接口 返回类型是Student

public interface StudentInterface {
    Student getStudent(String name,int grade);
}

　　代码这么走：

        StudentInterface studentInterface = Student::new;
        Student student = studentInterface.getStudent("小明",2);
        System.out.println(student.getName()+student.getGrade());

　　思考一下，Student类中有两个构造函数，为什么代码就逮着第二个构造函数走呢？

　　这就是lambda的类型推断特性了，走哪个构造函数是根据上下文的函数式接口来决定的，StudentInterface接口的入参是两个参数，一个String一个int，返回类型是Student，出入条件都符合第二个构造函数，所以它就会走第二个构造函数。

　　那如果我要走第一个构造函数该怎么做呢？

很简单，稍微改一下

public interface StudentInterface2 {
    Student getStudent(String name);
}

　　用这个函数式接口去接收方法引用即可。

泛型中的方法引用

　　在泛型类或泛型方法中也可以使用方法引用，再来一个例子：

　　这个是要引用的泛型方法

public class MyInfo2 {
    static <T> String name(String name,T age){
        return name+"年龄是"+age;
    }
}

　　函数式接口

public interface MyUser<T> {
    String userInfo(String name,T age);
}

　　调用

        String name = "小明";
        int age = 16;
        double a = 16.6;
        MyUser user = MyInfo2::name;
        String info = user.userInfo(name,age);
        System.out.println(info);

　　这里传int或double都是可以的。

　　如果要限制只能传int呢？

　　那就这样子 

MyUser<Integer> user = MyInfo2::name; //这时传double就不行了

　　请注意，它的原型实际上是这样的：

MyUser<Integer> user = MyInfo2::<Integer>name;

　　但是由于存在类型推断，所以::后面的类型指定是可以省略的。

内置的函数式接口

　　当我们设计自己的函数式接口时，可以用注解@FunctionalInterface来标记这个接口，这样子这个接口就只能成为函数式接口，不允许再增加别的抽象方法，另外javadoc里也会指出这是一个函数式接口。

　　当然，最好还是使用Java给我们内置的函数式接口，个人认为已经可以满足大部分编程需要了，并且很多接口都有非抽象的方法可以使用。

以下列出常用的函数式接口：

函数式接口	返回类型	参数类型	抽象方法名
Runnable	void	无	run
Supplier<T>	T	无	get
Consumer<T>	void	T	accept
BiConsumer<T,U>	void	T,U	accept
Function<T,R>	R	T	apply
BiFunction<T,U,R>	R	T,U	apply
UnaryOperator<T>	T	T	apply
BinaryOperator<T>	T	T,T	apply
Predicate<T>	boolean	T	test
BiPredicate<T,U>	boolean	T,U	test

基本类型函数式接口 

　　如 ToLongFunction IntToLongFunction IntConsumer 等等等等  接口名称已经代表了他们的功能

　　有三四十个这样的函数式接口，我这里就不方便出来了，详细请查阅java.util.function包。