概述

　　Lambda表达式，也可称为闭包，是JDK8的新特性。Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中），可以使代码变的更加简洁紧凑。Lambda表达式是一个可传递的代码块，可以在以后执行一次或多次。

　　名字起源是以前还没有计算机时，逻辑学家Alonzo Church想要形式化的表示能有效计算的数学函数，使用了希腊字母lambda（λ \lambdaλ）来标记参数，从那以后，带参数变量的表达式就被称为lambda表达式。

　　lambda表达式本质是一个匿名函数，比如以下函数

public int add(int x, int y) {
    return x + y;
}

　　可以转换为:

(int x, int y) -> x + y;

语法

　　语法格式如下

(parameters) -> expression

　　或

(parameters) ->{ statements; }

　　其中()用来描述参数列表，{}用来描述方法体，->是lambda运算符，读作goes to。

　　可以包含显示的return语句，如：

(String sirst,String second)->
{
    if(first.length()<second.length())return -1;
    else if(first.length()>second.length())return 1;
    else return 0;
}

　　可以没有参数，但()不可缺省：

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

　　如果可以推导出参数类型，则可以忽略其类型：

Comparator<String>cmp=(first,second)->first.length()-second.length();

　　特别注意不能只在某些分支返回一个值，这是不合法的，如：

(int x)->{if(x>=0)return 1;}

　　常用示例：

ArrayList<Integer>list=new ArrayList<>();
Collections.addAll(list,1,2,3,4,5);
//遍历
list.forEach(e->{System.out.println(e);});
//删除指定值
list.removeIf(e->e==3);
//排序
list.sort((o1,o2)->o2-o1);
//遍历（双冒号操作符）
list.forEach(System.out::println);

函数式接口

　　Java中又很多封装代码块的接口，如ActionListener、Comparator等，lambda表达式与这些接口时兼容的。
　　对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式，这种接口称为函数式接口。

　　比如Arrays.sort()方法，它的第二个参数需要一个Comparator实例，而Comparator就是只有一个方法的接口，所以可以使用lambda表达式替代，可以把lambda表达式看作一个函数，而不是一个对象，如：

Arrays.sort(arrays,
    (first,second)->first.length()-second.length());

　　lambda表达式还可以转换为接口，比如实现Runnable接口：

new Thread(() -> System.out.println("记得一键三连")).start();
Runnable r = () -> System.out.println("(。・∀・)ノ");
r.run();

　　再如之前提到的removeIf()方法，它的参数就是一个Predicate接口（位于java.util.function包），这个接口专门用来传递lambda表达式，如删除一个数组列表所有null值：

list.removeIf(e->e==null)

方法引用

　　当在Lambda表达式中直接调用了一个方法时可以使用，其写法为目标引用::方法名称。
　　有时候，可能已经有现成的方法可以完成你想要传递到其他代码的某个动作，如遍历打印集合：

list.forEach(e->{System.out.println(e);});

　　我们可以直接把现成的println方法传递给它：

list.forEach(System.out::println);

　　它们是等价的，是一个方法引用的写法。
　　再如对字符串排序而不考虑大小写，可以直接传递以下方法表达式：

Arrays.sort(strings,String::compareToIgnoreCase);

　　也就是说使用双冒号操作符::来分离方法名与对象或类名：

object::instanceMethod

Class::staticMethod

Class::instanceMethod

　　对于前两种情况，方法引用等价于提供方法参数的lambda表达式，如

Math::Pow 等价于 (x,y) -> Math.pos(x,y) 

　　对于第三种情况，第一个参数会成为方法的目标，如

String::compareToIgnoreCase 等同于 (x,y) -> x.compareToIgnoreCase(y) 

　　也可以在方法中引用this参数，如this::equals等价于x->this.equals(x)，同样的，使用super也是允许的。

构造器引用

　　构造器引用与方法引用很类似，只不过方法名为new，例如Person::new是Person类构造器的一个引用，如果有多个构造器，编译器会取决于上下文。比如有一个字符串列表，可以把他转换为一个Person对象数组，为此要在各个字符串上调用构造器。

　　可以用数组类型建立构造器引用，如int[]::new是一个构造器引用，它有一个参数即数组长度，等价于lambda表达式：x->new int[x];

　　在Java中无法构造泛型类型T的数组，而数组构造器引用就可克服这个限制。如表达式new T[n]会产生错误，因为这会改为new Object[n]。设我们需要一个Person对象数组，Stream接口有一个toArray方法可以返回Object数组：

Object[] people=stream.toArray();

　　以上得到的是一个Object引用数组，可以把Person[]::new传入给toArray()方法，从而得到一个Person对象数组：

Object[] people=stream.toArray(Person[]::new);

变量作用域

　　有时候，我们希望能够在lambda表达式中访问外围方法或类中的变量，如下面例子：

public static void printTip(String text) {
        Runnable r = () -> System.out.println(text);
        r.run();
}
public static void main(String[] args) {
    String text="一键三连";
    printTip(text);
}

　　现在来看lambda表达式中的text变量，它并不是在这个lambda表达式中定义的，实际上是printTip方法的一个参数变量。但仔细想想，lambda表达式的代码可能会在printTip调用返回很久以后才运行，而那时这个参数变量已经不存在了，如何保留text变量？

　　首先巩固瞎lambda表达式的理解，lmabda表达式有3个部分：一个代码块、变量、自由变量的值（指非参数而且不在代码中定义的变量）。在上面的例子中，lambda表达式有一个自由变量text，表示lambda表达式的数据结构必须存储的值（这里的字符串“一键三连”），我们称它被lambda表达式捕获（captured）。

　　关于代码块和自由变量值有一个术语：闭包（closure），在Java中，lambda表达式就是闭包。

　　lambda表达式捕获变量必须遵循的规则：捕获的变量必须实际上必须是最终变量(effectively final)，最终变量是指这个变量初始化之后就不会再为它赋新值，即在lambda表达式内外都不能在修改值。

　　如lambda内修改：

public static void printTip(String text) {
    Runnable r = () -> {
        System.out.println(text);
        text="修改值会报错";
    };
    r.run();
}
public static void main(String[] args) {
    String text="一键三连";
    printTip(text);
}

　　lambda外修改：

public static void main(String[] args) {
    for(int i=0;i<5;i++){
        //表达式外修改变量i报错
        Runnable r = () -> System.out.println(i);
        r.run();
    }
}

　　此外，在方法中不能有同名的局部变量，lambda表达式也是如此：

public static void main(String[] args) {
    int first=666;
    //同名会报错
    Comparator<String> cmp=
        (first,second)->first.length()-second.length();
}

　　对于lambda表达式中使用this关键字时，是指创建这个lambda表达式的方法饿this参数。

处理lambda表达式

　　使用lambda表达式的重点是延迟执行（deferred execution）。如果要立即执行代码的画完全可以直接执行而无需放到一个lambda表达式中，之所以希望以后在执行代码，这有很多原因，如：

• 在一个单独的线程中运行代码
• 多次运行代码
• 在算法的适当位置运行代码
• 发生某种情况时执行代码
• 只有在必要时才运行代码

　　设想要重复一个动作n次，将这个动作和重复次数，传递到一个repeat方法，要接受这个lambda表达式需要选择一个函数式接口，在这里我们可以使用Runnable接口，后面给出Java API中提供的最重要的函数式接口。

public static void repeat(int n,Runnable action){
    for(int i=0;i<n;i++)
        action.run();
}
public static void main(String[] args) {
    repeat(10,()-> System.out.println("一键三连"));
}

   函数式接口     参数类型  返回类型   抽象方法名       描述                  其他方法
----------------------------------------------------------------------------------------
Runnable            无      void       run     作为无参数或返回值的动作执行    
Supplier<T>         无        T        get     提供一个T类型的值    
Consumer<T>         T       void      accept   处理一个T类型的值        addThen
BiConsumer<T,U>    T,U      void      accept   处理T和U类型的值         addThen
Function<T,R>       T         R       apply    有一个T类型参数的函数    compose,addThen,idenity
BiFunction<T,U,R>  T,U        R       apply    有T和U类型参数的函数     addThen
UnaryOperator<T>    T         T       apply    类型T上的一元操作符      compose,addThen,identity
BinaryOperator<T>  T,T        T       apply    类型T上的二元操作符      addThen,maxBy,minBy
PreDicate<T>        T      boolean     test    布尔值函数              add,or,negate,isEqual
BiPredicate        T,U     boolean     test    有两个参数的布尔值函数   add,or,negate

　　现在让这个例子更复杂一些，我们希望知道这个动作出现在哪一次迭代中。为此需要选择一个合适的函数式接口，其中要包含一个方法，这个方法有一个int参数而且返回类型为void，如下所示：

public interface IntConsumer{
    void accept(int value);
}
public static void repeat(int n,IntConsumer action){
    for(int i=0;i<n;i++)
        action.accept(i);
}
public static void main(String[] args) {
    repeat(10,i-> System.out.println(9-i));
}

　　下表列出了基本类型int、long和double的34个可能的规范，最好使用这些特殊化规范来减少自动装箱：

函数式接口    参数类型    返回类型    抽象方法名
----------------------------------------------------------
BooleanSupplier    none    boolean    getAsBoolean
P PPSupplier    none    p pp    getAsP PP
P PPConsumer    p pp    void    accept
ObjP PPConsumer<T>    T,p pp    void    accept
P PPFunction<T>    p pp    T    apply
P PPToQFunction    p pp    q qq    applyAsQ QQ
ToP PPFunction<T>    T    p pp    applyAsP PP
ToP PPBiFunction<T,U>    T,U    p pp    applyAsP PP
P PPUnaryOperator    p pp    p pp    applyAsP PP
P PPBinaryOperator    p pp,p pp    p pp    applyAsP PP
P PPPredicate    p pp    boolean    test

　　p pp,q qq为int,long,double；
　　P PP,Q QQ为Int,Long,Double。

————————————————
版权声明：本文为CSDN博主「吾仄lo咚锵」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_45034708/article/details/117357492