本文首先介紹什麼是Lambda表達式，然後講解它的語法規則，接著對Lambda表達式的應用進行舉例，最後探討Lambda表達式的底層實現原理。 ...

Lambda表達式初體驗

簡介

Lambda 表達式（lambda expression）是一個匿名函數，Lambda表達式基於數學中的λ演算得名，直接對應於其中的lambda抽象（lambda abstraction），是一個匿名函數，即沒有函數名的函數。Lambda表達式可以表示閉包（註意和數學傳統意義上的不同）。

——《百度百科》

Java對於Lambda表達式的支持是從JDK8開始的，它來源於數學中的λ演算，是一套關於函數$f(x)$定義、輸入量、輸出量的計算方案，簡化了匿名函數的編寫，使代碼變得簡潔。
另外，提到Lambda表達式，就不得不提及函數式編程。

函數式編程

函數式編程，或稱函數程式設計、泛函編程（英語：Functional programming），是一種編程範式，它將電腦運算視為函數運算，並且避免使用程式狀態以及易變對象。其中，λ演算為該語言最重要的基礎。而且，λ演算的函數可以接受函數作為輸入參數和輸出返回值。
比起指令式編程，函數式編程更加強調程式執行的結果而非執行的過程，倡導利用若幹簡單的執行單元讓計算結果不斷漸進，逐層推導複雜的運算，而不是設計一個複雜的執行過程。
在函數式編程中，函數是頭等對象，意思是說一個函數，既可以作為其它函數的輸入參數值，也可以從函數中返回值，被修改或者被分配給一個變數。

——《維基百科》

總結函數式編程的特點：

函數是“頭等公民”
可以賦值給變數
可以作為其它函數的參數進行傳遞
可以作為其它函數的返回值

接下來用一個例子感受一下什麼是Lambda表達式。

舉個例子

首先聲明一個介面Factory和一個User類。

public interface Factory {
    Object getObject();
}

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

    public User() {}
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "User{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
    }
}

按照傳統的方式，想要實現Factory介面中的抽象方法，有兩種方法：

子類實現介面
匿名內部類

對於第一種方式，代碼如下：

public class SubClass implements Factory {
    @Override
    public Object getObject() {
        return new User("tom", 20);
    }
}
public class Code01_LambdaTest {
    public static void main(String[] args) {
        // 子類實現介面
        Factory factory = new SubClass();
        System.out.println("user = " + user);
    }
}

對於第二種方式，代碼如下：

public class Code01_LambdaTest {
    public static void main(String[] args) {
        // 匿名內部類
        Factory factory = new Factory() {
            @Override
            public Object getObject() {
                return new User("John", 18);
            }
        };
        System.out.println("user = " + user);
    }
}

分析上面的代碼，發現介面Factory中僅僅只有一個抽象方法，我們的目的是為了獲取User類的對象這麼一個簡單的操作，卻需要書寫這麼多代碼，最最核心的其實就是這一句return new User("John", 18)，有沒有更加簡潔的書寫方式實現上面的需求呢？
第三種方法，就是我們要介紹的Lambda表達式。請看代碼：

public class Code01_LambdaTest {
    public static void main(String[] args) {
        // lambda表達式
        Factory factory = () -> new User("Mike", 30);
        System.out.println("user = " + user);
    }
}

通過對比就會發現，代碼是多麼的簡潔高效！

Lambda表達式的語法格式

使用前提

必須要有一個函數式介面，有且僅有一個抽象方法的介面，要添加註解@FunctionalInterface！

兩種語法格式

(parameters) -> {statements}
(patameters) -> expression

說明如下：

parameters是函數的參數列表
當參數不止一個時，()不可省略，否則可以省略()和類型；
當函數式介面中抽象方法的參數列表的參數類型可以自動推斷時，可以省略對應的類型
statements是執行語句
當函數體僅有一個語句，可以省略{}，否則不可省略；
expression是表達式
當函數體只有一個表達式，且運算結果匹配返回值類型，可以省略return關鍵字
->是使用指定參數去完成某個功能，不可省略

常見的函數式介面

Runnable、Callable
Supplier、Consumer
Comparator
Predicate
Function

Lambda表達式應用舉例

註意，以下源碼是基於Java17的。

Runnable、Callable介面

介面介紹

Java-多線程：Callable介面和Runnable介面之間的區別

介面源碼

package java.lang;

@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

package java.util.concurrent;

@FunctionalInterface
public interface Callable<V> {
    V call() throws Exception;
}

案例

public static void main(String[] args) {
    // 使用匿名內部類的方式實現多線程
    new Thread(new Runnable() {
        @Override
        public void run() {
            String name = Thread.currentThread().getName();
            System.out.println("線程 " + name + " 已啟動!");
        }
    }).start();
    // 使用Lambda表達式
    new Thread(() -> {
        String name = Thread.currentThread().getName();
        System.out.println("Lambda::線程 " + name + " 已啟動!");
    }).start();
}

Supplier、Consumer介面

介面介紹

Supplier介面是一個供給型的介面，需要實現get方法。它更像是一個容器，可以用來存儲數據，然後可以供其他方法使用。
Consumer介面就是一個消費型的介面，通過傳入參數，然後輸出值。Consumer是一個介面，並且只要實現一個accept方法，就可以作為一個消費者輸出信息。andThen方法的返回值仍為Consumer介面，因此可以持續消費。

介面源碼

package java.util.function;

@FunctionalInterface
public interface Supplier<T> {
    T get();
}

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

案例

對於Supplier供應商介面，我們求數組arr中的最大值。

public static void main(String[] args) {
    int[] arr = {1, 5, 7, 9, 2, 4, 6, 8};
    // 獲取數組的最大值
    Supplier<Integer> supplier = () -> {
        int max = Integer.MIN_VALUE;
        for (int j : arr) {
            if (j > max) max = j;
        }
        return max;
    };
    System.out.println(supplier.get());
}

對於Consumer消費者介面，我們測試持續消費。

public static void consumer(Consumer<String> first, Consumer<String> sec) {
    first.andThen(sec).accept("Tt");
}

然後在main方法中，先消費一條消息"hello"，接著再消費一條消息"Tt"

public static void main(String[] args) {
    Consumer<String> consumer = msg -> System.out.println("msg = " + msg);
    consumer.accept("hello");
    consumer(
        consumer,
        s -> System.out.println(s.toUpperCase())
    );
}

程式的運行結果為：

msg = hello
msg = Tt
TT

Comparator介面

介面介紹

Comparator介面是一個專用的比較器，當這個對象不支持自比較或者自比較函數不能滿足要求時，可寫一個比較器來完成兩個對象之間大小的比較。Comparator體現了一種策略模式(strategy design pattern)，就是不改變對象自身，而用一個策略對象(strategy object)來改變它的行為。

強行對某個對象collection進行整體排序的比較函數。可以將 Comparator 傳遞給 sort 方法（如 Collections.sort 或 Arrays.sort）,從而允許在排序順序上實現精確控制。還可以使用 Comparator 來控制某些數據結構（如有序 set 或有序映射）的順序，或者為那些沒有自然順序的對象 collection 提供排序。
當且僅當對於一組元素 S 中的每個 e1 和 e2 而言，c.compare(e1, e2)==0 與 e1.equals(e2) 具有相等的布爾值時，Comparator c 強行對 S 進行的排序才叫做與 equals 一致的排序。
當使用具有與 equals 不一致的強行排序能力的 Comparator 對有序 set（或有序映射）進行排序時，應該小心謹慎。假定一個帶顯式 Comparator c 的有序 set（或有序映射）與從 set S 中抽取出來的元素（或鍵）一起使用。如果 c 強行對 S 進行的排序是與 equals 不一致的，那麼有序 set（或有序映射）將是行為“怪異的”。尤其是有序 set（或有序映射）將違背根據 equals 所定義的 set（或映射）的常規協定。
例如，假定使用 Comparator c 將滿足 (a.equals(b) && c.compare(a, b) != 0) 的兩個元素 a 和 b 添加到一個空 TreeSet 中，則第二個 add 操作將返回 true（樹 set 的大小將會增加），因為從樹 set 的角度來看，a 和 b 是不相等的，即使這與 Set.add 方法的規範相反。
註：通常來說，讓Comparator也實現 java.io.Serializable 是一個好主意，因為它們在可序列化的數據結構（像 TreeSet 、TreeMap）中可用作排序方法。為了成功地序列化數據結構，Comparator(如果已提供)必須實現Serializable。

——《官方文檔》

這裡不得不提Comparable介面：

此介面強行對實現它的每個類的對象進行整體排序。這種排序被稱為類的自然排序，類的compareTo方法被稱為它的自然比較方法。
實現此介面的對象列表（和數組）可以通過Collections.sort(和Arrays.sort)進行自動排序。實現此介面的可以用作有序映射(實現了SortedMap介面的對象)或有序集合(實現了SortedSet介面的對象)中的元素，無需指定比較器。
建議（雖然不是必需的）最好使自然排序與equals一致。所謂自然排序與equals一致指的是類A 對於每一個 o1 和 o2 來說，當且僅當 ( o1.compareTo( o2 ) )與 o1.equals( o2 )具有相同的布爾值時，類A的自然排序才叫做與equals一致。

——《官方文檔》

兩個介面有什麼區別？

Comparator位於包java.util下，而Comparable位於包java.lang下。
Comparable介面將比較代碼寫入需要進行比較類的代碼中，而Comparator介面在一個獨立的類中實現比較。
Comparator介面相對更靈活，因為它跟介面實現的類是耦合在一起的，可以通過更換比較器來改變不同的比較規則。
Comparable介面強制進行自然排序，而Comparator介面不強制進行自然排序，可以指定排序順序。

介面源碼

package java.util;

import java.io.Serializable;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
import java.util.Comparators;

@FunctionalInterface
public interface Comparator<T> {
    int compare(T o1, T o2);
    
    boolean equals(Object obj);
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }
    default Comparator<T> thenComparing(Comparator<? super T> other) {
        Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }
    ...
}

註意：boolean equals(Object obj);是屬於父類Object的，因此它還是函數式介面，仍然只有一個抽象方法int compare(T o1, T o2);。

案例

public static void main(String[] args) {
    String[] arr = {"ab", "c", "d", "go", "bee"};
    Comparator<String> comparator = String::compareTo;
    comparator = Comparator.reverseOrder();
    comparator = (o1, o2) -> o2.length() - o1.length();
    Arrays.sort(arr, comparator);
    System.out.println("arr = " + Arrays.toString(arr));
}

依次運行的結果：

arr = [ab, bee, c, d, go]
arr = [go, d, c, bee, ab]
arr = [bee, go, ab, d, c]

Predicate介面

介面介紹

Predicate介面主要用於流的篩選。給定一個包含若幹項的流，Stream 介面的filter方法傳入Predicate 並返回一個新的流，它僅包含滿足給定謂詞的項。可以使用 lambda 表達式或方法引用來實現boolean test(T t)方法。

介面源碼

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
    
    default Predicate<T> and(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }
    default Predicate<T> negate() {
        return (t) -> !test(t);
    }
    default Predicate<T> or(Predicate<? super T> other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }
    static <T> Predicate<T> isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
    static <T> Predicate<T> not(Predicate<? super T> target) {
        Objects.requireNonNull(target);
        return (Predicate<T>)target.negate();
    }
}

註意：Predicate介面包含的單一抽象方法為boolean test(T t)，它傳入一個泛型參數並返回true或 false。

案例

給定一個字元串String str = "Hello the world !";判斷是否包含指定的字元。
定義3個方法，分別實現與、或、非的功能。

public static boolean and(Predicate<String> p1, Predicate<String> p2, String s) {
    return p1.and(p2).test(s);
}

public static boolean or(Predicate<String> p1, Predicate<String> p2, String s) {
    return p1.or(p2).test(s);
}

public static boolean negate(Predicate<String> p, String s) {
    return p.negate().test(s);
}

然後在main方法中調用

public static void main(String[] args) {
    String str = "Hello the world !";
    boolean ans;
    ans = and(s -> s.contains("H"), s -> s.contains("w"), str);
    ans = or(s -> s.contains("A"), s -> s.contains("z"), str);
    ans = negate(s -> s.length() < 10, str);
    System.out.println("ans = " + ans);
}

逐一運行，運行結果為：

ans = true
ans = false
ans = true

Function介面

介面介紹

函數式介面(Functional Interface)有且僅有一個抽象方法，但是可以有多個非抽象方法的介面。函數式介面可以被隱式轉換為 Lambda 表達式。
Java 8 中提供了一個函數式介面 Function，這個介面表示對一個參數做一些操作然後返回操作之後的值。這個介面的有一個抽象方法 apply，這個方法就是表明對參數做的操作。

介面源碼

package java.util.function;

import java.util.Objects;

@FunctionalInterface
public interface Function<T, R> {
    R apply(T t);
    
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }
    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }
    static <T> Function<T, T> identity() {
        return t -> t;
    }
}

註意：

這裡的抽象方法是apply，可以從數學上理解Function介面，即$f:T \rightarrow R$，輸入一個$T$可以返回一個$R$，$f$就是定義的一套規則，交由apply執行。
對於andThen方法，它返回一個組合函數，一個函數的輸出將作為另一個函數的輸入。如果對任一函數的求值引發異常，則將異常拋給組合函數的調用方。

案例

接下來用對多項式進行求導的例子進行演示。
對於多項式$f(x) = 5x^3 + 2x^2 + x + 6$，定義數組C=[5,2,1,6]表示它的繫數。
首先定義一個用於求導數的lambda表達式：

Function<Integer[], Integer[]> d = x -> {
    if (x.length == 1) {
        return new Integer[]{0};
    }
    Integer[] C1 = new Integer[x.length - 1];
    for (int i = 0; i < x.length - 1; i++) {
        C1[i] = x[i] * (x.length - 1 - i);
    }
    return C1;
};

為了方便查看，定義一個列印多項式的方法：

public static void showX(Integer[] C) {
    if (C.length == 1) {
        System.out.println("f(x) = " + C[0]);
        return;
    }
    StringBuilder s = new StringBuilder();
    int size = C.length - 1;
    for (int i = 0; i <= size; i++) {
        int pow = size - i;
        if (C[i] != 0 && pow > 0) {
            if (C[i] != 1) s.append(C[i]);
            if (pow == 1) s.append("x");
            else s.append("x^").append(pow);
            s.append(" + ");
        }
        if (C[i] != 0 && pow == 0) s.append(C[i]);
    }
    System.out.println("f(x) = " + s);
}

接下來就可以在main方法里進行調用了，我們可以藉助Function介面中的apply方法對多項式進行多次求導。

public static void main(String[] args) {
    // 求多項式二階導數
    // f(x) = 5x^3 + 2x^2 + x + 6
    // 繫數 = [5,2,1,6]
    // 冪次 = [3,2,1,0]
    // 預期繫數 = [30,4]
    // 預期冪次 = [1,0]
    Integer[] C = {5, 2, 1, 6};
    showX(C);

    // 求一階導數
    Integer[] C1 = d.apply(C);
    showX(C1);
    // 求二階導數
    Integer[] C2 = d.andThen(d).apply(C);
    showX(C2);
    // 求三階導數
    Integer[] C3 = d.andThen(d.andThen(d)).apply(C);
    showX(C3);
}

執行結果：

f(x) = 5x^3 + 2x^2 + x + 6
f(x) = 15x^2 + 4x + 1
f(x) = 30x + 4
f(x) = 30

Lambda的底層實現原理剖析

Lambda表達式的本質

它的本質是函數式介面的匿名子類的匿名對象。底層是依賴ASM技術、由匿名內部類實現的，由於Java是面向對象的語言，因此Lambda表達式是一個語法糖，它不能直接執行，需要轉換成內部類才可以運行。

編譯和運行的過程圖

以下麵的代碼舉例：

import java.util.Arrays;
import java.util.List;

public class LambdaPrinciple {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("I", "Love", "You");
        list.forEach(s -> System.out.println(s));
    }
}

上述代碼的編譯和運行過程如圖1所示：

詳細過程分析

通過反編譯得到位元組碼文件，可以分析Lambda表達式的本質。將cfr-0.145.jar包添加到LambdaPrinciple類的編譯路徑，如圖2所示。

執行反編譯命令：java -jar cfr-0.145.jar LambdaPrinciple.class --decodelambdas false，如圖3所示。

得到反編譯的LambdaPrinciple.class

import java.io.PrintStream;
import java.lang.invoke.LambdaMetafactory;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;

public class LambdaPrinciple {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("I", "Love", "You");
        list.forEach((Consumer<String>) LambdaMetafactory.metafactory(
            null, null, null, 
            (Ljava / lang / Object;)V, 
            lambda$main$0(java.lang.String), 
            (Ljava / lang / String;)V)());
    }

    private static /* synthetic */ void lambda$main$0(String s) {
        System.out.println(s);
    }
}

從上面可以看到，Lambda表達式最終被編譯成lambda$main$0靜態方法去執行。
接下來找到LambdaMetafactory.java，看下它的metafactory方法

public final class LambdaMetafactory {
    ...
    // LambdaMetafactory bootstrap methods are startup sensitive, and may be
    // special cased in java.lang.invoke.BootstrapMethodInvoker to ensure
    // methods are invoked with exact type information to avoid generating
    // code for runtime checks. Take care any changes or additions here are
    // reflected there as appropriate.

    /**
     * Facilitates the creation of simple "function objects" that implement one
     * or more interfaces by delegation to a provided {@link MethodHandle},
     * after appropriate type adaptation and partial evaluation of arguments.
     * Typically used as a <em>bootstrap method</em> for {@code invokedynamic}
     * call sites, to support the <em>lambda expression</em> and <em>method
     * reference expression</em> features of the Java Programming Language.
     *
     * <p>This is the standard, streamlined metafactory; additional flexibility
     * is provided by {@link #altMetafactory(MethodHandles.Lookup, String, MethodType, Object...)}.
     * A general description of the behavior of this method is provided
     * {@link LambdaMetafactory above}.
     *
     * <p>When the target of the {@code CallSite} returned from this method is
     * invoked, the resulting function objects are instances of a class which
     * implements the interface named by the return type of {@code factoryType},
     * declares a method with the name given by {@code interfaceMethodName} and the
     * signature given by {@code interfaceMethodType}.  It may also override additional
     * methods from {@code Object}.
     *
     * @param caller Represents a lookup context with the accessibility
     *               privileges of the caller.  Specifically, the lookup context
     *               must have {@linkplain MethodHandles.Lookup#hasFullPrivilegeAccess()
     *               full privilege access}.
     *               When used with {@code invokedynamic}, this is stacked
     *               automatically by the VM.
     * @param interfaceMethodName The name of the method to implement.  When used with
     *                            {@code invokedynamic}, this is provided by the
     *                            {@code NameAndType} of the {@code InvokeDynamic}
     *                            structure and is stacked automatically by the VM.
     * @param factoryType The expected signature of the {@code CallSite}.  The
     *                    parameter types represent the types of capture variables;
     *                    the return type is the interface to implement.   When
     *                    used with {@code invokedynamic}, this is provided by
     *                    the {@code NameAndType} of the {@code InvokeDynamic}
     *                    structure and is stacked automatically by the VM.
     * @param interfaceMethodType Signature and return type of method to be
     *                            implemented by the function object.
     * @param implementation A direct method handle describing the implementation
     *                       method which should be called (with suitable adaptation
     *                       of argument types and return types, and with captured
     *                       arguments prepended to the invocation arguments) at
     *                       invocation time.
     * @param dynamicMethodType The signature and return type that should
     *                          be enforced dynamically at invocation time.
     *                          In simple use cases this is the same as
     *                          {@code interfaceMethodType}.
     * @return a CallSite whose target can be used to perform capture, generating
     *         instances of the interface named by {@code factoryType}
     * @throws LambdaConversionException If {@code caller} does not have full privilege
     *         access, or if {@code interfaceMethodName} is not a valid JVM
     *         method name, or if the return type of {@code factoryType} is not
     *         an interface, or if {@code implementation} is not a direct method
     *         handle referencing a method or constructor, or if the linkage
     *         invariants are violated, as defined {@link LambdaMetafactory above}.
     * @throws NullPointerException If any argument is {@code null}.
     * @throws SecurityException If a security manager is present, and it
     *         <a href="MethodHandles.Lookup.html#secmgr">refuses access</a>
     *         from {@code caller} to the package of {@code implementation}.
     */
    public static CallSite metafactory(MethodHandles.Lookup caller,
                                       String interfaceMethodName,
                                       MethodType factoryType,
                                       MethodType interfaceMethodType,
                                       MethodHandle implementation,
                                       MethodType dynamicMethodType)
    throws LambdaConversionException {
        AbstractValidatingLambdaMetafactory mf;
        mf = new InnerClassLambdaMetafactory(Objects.requireNonNull(caller),
                                             Objects.requireNonNull(factoryType),
                                             Objects.requireNonNull(interfaceMethodName),
                                             Objects.requireNonNull(interfaceMethodType),
                                             Objects.requireNonNull(implementation),
                                             Objects.requireNonNull(dynamicMethodType),
                                             false,
                                             EMPTY_CLASS_ARRAY,
                                             EMPTY_MT_ARRAY);
        mf.validateMetafactoryArgs();
        return mf.buildCallSite();
    }
}

接下來看下new InnerClassLambdaMetafactory()的代碼，它的作用是創建內部類

public InnerClassLambdaMetafactory(MethodHandles.Lookup caller,
                                   MethodType factoryType,
                                   String interfaceMethodName,
                                   MethodType interfaceMethodType,
                                   MethodHandle implementation,
                                   MethodType dynamicMethodType,
                                   boolean isSerializable,
                                   Class<?>[] altInterfaces,
                                   MethodType[] altMethods)
    throws LambdaConversionException {
    super(caller, factoryType, interfaceMethodName, interfaceMethodType,
        implementation, dynamicMethodType,
        isSerializable, altInterfaces, altMethods);
    implMethodClassName = implClass.getName().replace('.', '/');
    implMethodName = implInfo.getName();
    implMethodDesc = implInfo.getMethodType().toMethodDescriptorString();
    constructorType = factoryType.changeReturnType(Void.TYPE);
    lambdaClassName = lambdaClassName(targetClass);
    // If the target class invokes a protected method inherited from a
    // superclass in a different package, or does 'invokespecial', the
    // lambda class has no access to the resolved method. Instead, we need
    // to pass the live implementation method handle to the proxy class
    // to invoke directly. (javac prefers to avoid this situation by
    // generating bridges in the target class)
    useImplMethodHandle = (Modifier.isProtected(implInfo.getModifiers()) &&
                           !VerifyAccess.isSamePackage(targetClass, implInfo.getDeclaringClass())) ||
        implKind == H_INVOKESPECIAL;
    cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
    int parameterCount = factoryType.parameterCount();
    if (parameterCount > 0) {
        argNames = new String[parameterCount];
        argDescs = new String[parameterCount];
        for (int i = 0; i < parameterCount; i++) {
            argNames[i] = "arg$" + (i + 1);
            argDescs[i] = BytecodeDescriptor.unparse(factoryType.parameterType(i));
        }
    } else {
        argNames = argDescs = EMPTY_STRING_ARRAY;
    }
}

值得註意的是cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);，它的作用是構造一個新的ClassWriter對象，寫位元組碼文件，這其實就是ASM技術。
回到LambdaMetafactory.java，查看metafactory方法它的返回值，走到這一步時，其實準備工作已經完成了，關鍵的代碼是final Class<?> innerClass = spinInnerClass();要返回內部類的位元組碼文件。

@Override
CallSite buildCallSite() throws LambdaConversionException {
    final Class<?> innerClass = spinInnerClass();
    if (factoryType.parameterCount() == 0) {
        // In the case of a non-capturing lambda, we optimize linkage by pre-computing a single instance,
        // unless we've suppressed eager initialization
        if (disableEagerInitialization) {
            try {
                return new ConstantCallSite(caller.findStaticGetter(innerClass, LAMBDA_INSTANCE_FIELD,
                        factoryType.returnType()));
            } catch (ReflectiveOperationException e) {
                throw new LambdaConversionException(
                        "Exception finding " +  LAMBDA_INSTANCE_FIELD + " static field", e);
            }
        } else {
            @SuppressWarnings("removal")
            final Constructor<?>[] ctrs = AccessController.doPrivileged(
                    new PrivilegedAction<>() {
                        @Override
                        public Constructor<?>[] run() {
                            Constructor<?>[] ctrs = innerClass.getDeclaredConstructors();
                            if (ctrs.length == 1) {
                                // The lambda implementing inner class constructor is private, set
                                // it accessible (by us) before creating the constant sole instance
                                ctrs[0].setAccessible(true);
                            }
                            return ctrs;
                        }
                    });
            if (ctrs.length != 1) {
                throw new LambdaConversionException("Expected one lambda constructor for "
                        + innerClass.getCanonicalName() + ", got " + ctrs.length);
            }

            try {
                Object inst = ctrs[0].newInstance();
                return new ConstantCallSite(MethodHandles.constant(interfaceClass, inst));
            } catch (ReflectiveOperationException e) {
                throw new LambdaConversionException("Exception instantiating lambda object", e);
            }
        }
    } else {
        try {
            MethodHandle mh = caller.findConstructor(innerClass, constructorType);
            return new ConstantCallSite(mh.asType(factoryType));
        } catch (ReflectiveOperationException e) {
            throw new LambdaConversionException("Exception finding constructor", e);
        }
    }
}

接下來查看spinInnerClass的源碼

private Class<?> spinInnerClass() throws LambdaConversionException {
    // CDS does not handle disableEagerInitialization.
    if (!disableEagerInitialization) {
        // include lambda proxy class in CDS archive at dump time
        if (CDS.isDumpingArchive()) {
            Class<?> innerClass = generateInnerClass();
            LambdaProxyClassArchive.register(targetClass,
                                             interfaceMethodName,
                                             factoryType,
                                             interfaceMethodType,
                                             implementation,
                                             dynamicMethodType,
                                             isSerializable,
                                             altInterfaces,
                                             altMethods,
                                             innerClass);
            return innerClass;
        }

        // load from CDS archive if present
        Class<?> innerClass = LambdaProxyClassArchive.find(targetClass,
                                                           interfaceMethodName,
                                                           factoryType,
                                                           interfaceMethodType,
                                                           implementation,
                                                           dynamicMethodType,
                                                           isSerializable,
                                                           altInterfaces,
                                                           altMethods);
        if (innerClass != null) return innerClass;
    }
    return generateInnerClass();
}

接下來查看generateInnerClass()的源碼

private Class<?> generateInnerClass() throws LambdaConversionException {
    String[] interfaceNames;
    String interfaceName = interfaceClass.getName().replace('.', '/');
    boolean accidentallySerializable = !isSerializable && Serializable.class.isAssignableFrom(interfaceClass);
    if (altInterfaces.length == 0) {
        interfaceNames = new String[]{interfaceName};
    } else {
        // Assure no duplicate interfaces (ClassFormatError)
        Set<String> itfs = new LinkedHashSet<>(altInterfaces.length + 1);
        itfs.add(interfaceName);
        for (Class<?> i : altInterfaces) {
            itfs.add(i.getName().replace('.', '/'));
            accidentallySerializable |= !isSerializable && Serializable.class.isAssignableFrom(i);
        }
        interfaceNames = itfs.toArray(new String[itfs.size()]);
    }

    cw.visit(CLASSFILE_VERSION, ACC_SUPER + ACC_FINAL + ACC_SYNTHETIC,
             lambdaClassName, null,
             JAVA_LANG_OBJECT, interfaceNames);

    // Generate final fields to be filled in by constructor
    for (int i = 0; i < argDescs.length; i++) {
        FieldVisitor fv = cw.visitField(ACC_PRIVATE + ACC_FINAL,
                                        argNames[i],
                                        argDescs[i],
                                        null, null);
        fv.visitEnd();
    }

    generateConstructor();

    if (factoryType.parameterCount() == 0 && disableEagerInitialization) {
        generateClassInitializer();
    }

    // Forward the SAM method
    MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, interfaceMethodName,
                                      interfaceMethodType.toMethodDescriptorString(), null, null);
    new ForwardingMethodGenerator(mv).generate(interfaceMethodType);

    // Forward the altMethods
    if (altMethods != null) {
        for (MethodType mt : altMethods) {
            mv = cw.visitMethod(ACC_PUBLIC, interfaceMethodName,
                                mt.toMethodDescriptorString(), null, null);
            new ForwardingMethodGenerator(mv).generate(mt);
        }
    }

    if (isSerializable)
        generateSerializationFriendlyMethods();
    else if (accidentallySerializable)
        generateSerializationHostileMethods();

    cw.visitEnd();

    // Define the generated class in this VM.

    final byte[] classBytes = cw.toByteArray();
    // If requested, dump out to a file for debugging purposes
    if (dumper != null) {
        AccessController.doPrivileged(new PrivilegedAction<>() {
            @Override
            public Void run() {
                dumper.dumpClass(lambdaClassName, classBytes);
                return null;
            }
        }, null,
        new FilePermission("<<ALL FILES>>", "read, write"),
        // createDirectories may need it
        new PropertyPermission("user.dir", "read"));
    }
    try {
        // this class is linked at the indy callsite; so define a hidden nestmate
        Lookup lookup;
        if (useImplMethodHandle) {
            lookup = caller.defineHiddenClassWithClassData(classBytes, implementation, !disableEagerInitialization,
                                                           NESTMATE, STRONG);
        } else {
            lookup = caller.defineHiddenClass(classBytes, !disableEagerInitialization, NESTMATE, STRONG);
        }
        return lookup.lookupClass();
    } catch (IllegalAccessException e) {
        throw new LambdaConversionException("Exception defining lambda proxy class", e);
    } catch (Throwable t) {
        throw new InternalError(t);
    }
}

這裡要註意的是dumper，如果請求，轉儲到文件以進行調試，點進去，可以得到下麵的JVM參數：final String dumpProxyClassesKey = "jdk.internal.lambda.dumpProxyClasses";。
然後在LambdaPrinciple位元組碼文件所在的路徑，繼續反編譯，將內部類轉儲出來。
轉儲命令為：java -Djdk.internal.lambda.dumpProxyClasses LambdaPrinciple，得到LambdaPrinciple$$Lambda$1.class。
然後再將其進行反編譯java -jar cfr-0.145.jar LambdaPrinciple$$Lambda$1.class --decodelambdas false，得到如下的結果：

final class LambdaPrinciple$$Lambda$1 implements Consumer {
    private LambdaPrinciple$$Lambda$1() {
    }

    @LambdaForm.Hidden
    public void accept(Object object) {
        LambdaPrinciple.lambda$main$0((String)object);
    }
}

整合上面反編譯的代碼，如下所示：

public class LambdaPrinciple {
    final class LambdaPrinciple$$Lambda$1 implements Consumer {
    private LambdaPrinciple$$Lambda$1() {
    }

    @LambdaForm.Hidden
    public void accept(Object object) {
        LambdaPrinciple.lambda$main$0((String)object);
    }
}
    public static void main(String[] args) {
        List<String> list = Arrays.asList("I", "Love", "You");
        list.forEach((Consumer<String>) LambdaMetafactory.metafactory(
            null, null, null, 
            (Ljava / lang / Object;)V, 
            lambda$main$0(java.lang.String), 
            (Ljava / lang / String;)V)());
    }
	
    private static /* synthetic */ void lambda$main$0(String s) {
        System.out.println(s);
    }
}

至此，便可以清晰的看到Lambda表達式的編譯和運行過程，也更好的理解了Lambda表達式它的本質是函數式介面的匿名子類的匿名對象！

本文的所有代碼

可參考：https://github.com/aldalee/java-new-features/tree/master/lambda，稍有改動。

深入理解Lambda表達式

Lambda表達式初體驗

簡介

函數式編程

舉個例子

Lambda表達式的語法格式

使用前提

兩種語法格式

常見的函數式介面

Lambda表達式應用舉例

Runnable、Callable介面

介面介紹

介面源碼

案例

Supplier、Consumer介面

介面介紹

介面源碼

案例

Comparator介面

介面介紹

介面源碼

案例

Predicate介面

介面介紹

介面源碼

案例

Function介面

介面介紹

介面源碼

案例

Lambda的底層實現原理剖析

Lambda表達式的本質

編譯和運行的過程圖

詳細過程分析

本文的所有代碼