新发布的 Java 8 包含众多新特性，其中之一是 Java 8 支持了被 .net 玩烂了的 Lambda 表达式。

当然我们也不能说 Java 是后知后觉，Java 有自身的考虑。我觉得可能性更大的是 Java 支持 Lambda，只是采用了这种语法（或者说这种编程方式），实现上仍然是以前那套东西，只是在编译阶段和运行阶段做了一些“手脚”，让大家吃上了 Lambda 这颗语法糖。

基本使用

先看看 Lambda 表达式最简单的使用：

public class Main {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("baidu.com")).start();
    }
}
复制代码

经常用 Thread() 写 Demo 的同学，肯定能一眼发现这当中的  Lambda 表达式其实就是对应了 Runnable 中的 run() 方法。但是第一次接触 Lambda 表达式的同学，可能很难理解，这怎么就能对应上 Runnable 中的 run()  方法了？其实这里能用  Lambda 表达式是因为 Runnable 接口属于函数式接口。

所谓的函数式接口是指该接口只有唯一一个需要被实现的抽象接口。

这里的 Thread(Runnable target) 所需要传入的 Runnable 对象，正是一个只有一个方法需要实现的接口，属于函数式接口。而且函数式接口还有一个显式的特征，就是会带一个 @FunctionalInterface 注解：

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}
复制代码

除了无参、单行代码的情况，Lambda 表达式支持以下几种写法：

• 执行语句块
  public class Main { public static void main(String[] args) { new Thread(() -> { System.out.println("baidu.com"); System.out.println("baidu.com"); }).start(); } }
  
• 接受显式参数
  public class Main { public static void main(String[] args) { List list = new LinkedList<>(); // To prepare data ... Collections.sort(list, (Integer a, Integer b) -> { System.out.println(a); System.out.println(b); return Integer.compare(a, b); }); } }
  
• 接受隐式参数
  public class Main { public static void main(String[] args) { List list = new LinkedList<>(); // To prepare data ... Collections.sort(list, (a, b) -> { System.out.println(a); System.out.println(b); return Integer.compare(a, b); }); } }
  
• 自动处理返回值
  public class Main { public static void main(String[] args) { List list = new LinkedList<>(); // To prepare data ... Collections.sort(list, (a, b) -> Integer.compare(a, b)); } }
  
• 方法引用
  public class Main { public static void main(String[] args) { List list = new LinkedList<>(); // To prepare data ... Collections.sort(list, Integer::compare); } }
  

也就是说，最简单的 Lambda 表达式的形式化格式为：parameters -> an expression ，当有多个语句要执行时，可以使用 parameters -> {expressions;};。同时 Lambda 表达式具有推导参数类型和自动处理返回值的能力。

Lambda 的实现细节

在 Java 8 之前，我们主要有三种方式达到类似 Lambda 表达式的效果

1. 定义类来实现接口：
   public class Main { public static void main(String[] args) { Runnable runnable = new RunnableOuterImpl(); new Thread(runnable).start(); } }
   
2. 使用内部类：
   public class Main { static final class RunnableImpl implements Runnable { @Override public void run() { System.out.println("baidu.com"); } }

public static void main(String[] args) {
     Runnable runnable = new RunnableImpl();
     new Thread(runnable).start();
 }
复制代码

1. }

2. 使用匿名内部类：

public class Main { public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() { System.out.println("baidu.com"); } }).start(); } }

那么 Lambda 是通过以上三种方式的何种来实现的呢？

事实上，Lambda 表达式是通过内部类来实现的。完整的 Lambda 表达式的流程如下：

1. 在编译期，先创建一个私有的静态方法，静态方法的实现就是我们 Lambda 表达式里要做的事情

这一点，我们可以通过编译源码，再重新编译回去证实。我们可以编译以上的 Lambda 版本的 java 文件，得到对应的 class 文件，再通过 javap 进行反编译。得到以下反编译内容：

Compiled from "Main.java"
public class com.baidu.Main {
  public com.baidu.Main();
  public static void main(java.lang.String[]);
  private static void lambda$main$0();
}
复制代码

可以看到在 Main 类里面多了一个 lambdamainmainmain0 方法，说明 Lambda 表达式首先先生成一个私有的静态函数。这个函数里的实现就是我们在 Lambda 表达式里面的执行内容。

2. 在运行时，Lambda 表达式首次被执行时，动态生成一个对应接口的实现类

由于是运行时，最好的验证方法是通过断点的形式。在执行 Lambda 表达式的位置断点，可以看到执行表达式的时，是调用了 java.lang.invoke.LambdaMetafactory 类里面的 metafactory() 方法

public static CallSite metafactory(MethodHandles.Lookup caller,
                                   String invokedName,
                                   MethodType invokedType,
                                   MethodType samMethodType,
                                   MethodHandle implMethod,
                                   MethodType instantiatedMethodType)
    throws LambdaConversionException {
    AbstractValidatingLambdaMetafactory mf;
    mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                         invokedName, samMethodType,
                                         implMethod, instantiatedMethodType,
                                         false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
    mf.validateMetafactoryArgs();
    return mf.buildCallSite();
}
复制代码

为了确定这个动态生成的类在运行时真实存在，我们可以执行 Main.java 的时候，指定 JVM 参数 -Djdk.internal.lambda.dumpProxyClasses 类导出 Lambda 表达式生成的动态代理类。之后我们会在 Main.class 的同级目录下看到一个新的 class 文件：Main$$Lambda$1.class。

然后通过通过 javap 反编译一下：

➜  WorkSpace javap -c -p com.baidu.Main\$\$Lambda\$1
final class com.baidu.Main$$Lambda$1 implements java.lang.Runnable {
  private com.baidu.Main$$Lambda$1();
    Code:
       0: aload_0
       1: invokespecial #10                 // Method java/lang/Object."<init>":()V
       4: return
  public void run();
    Code:
       0: invokestatic  #17                 // Method com/baidu/Main.lambda$main$0:()V
       3: return
}
复制代码

可以看到运行时，JVM 会为 Lambda 表达式创建一个 Runnable 接口的实现类。里面有一个默认的构造方法和必须实现的 run() 方法。在 run() 方法中，调用了一个静态方法，这个静态方法就是我们刚刚说的，在编译期，生成的那个私有静态方法 lambdamainmainmain0()。

总结

总结一下，Lambda 表达式的实现本质就是内部类。先在编译器创建一个私有的静态方法，装着我们在 Lambda 表达式中需要实现的代码；然后在运行时创建一个实现了接口的内部类，在接口方法中调用编译器生成好的私有静态方法。