Lambda表示式可以理解為一種匿名函式：它沒有名稱，但是由引數列表，函式主體，返回型別，當然可能還有一個可以丟擲的異常的列表。

Lambda的基本語法是

(parameters) -> expression

或（請注意語句的花括號）

(parameters) -> { statements; }

根據上述語法規則，以下哪個不是有效的Lambda表示式？
(1) () -> {}
(2) () -> "Raoul"
(3) () -> {return "Mario";}
(4) (Integer i) -> return "Alan"
 
 + i;
(5) (String s) -> {"IronMan";}

答案：只有4和5是無效的Lambda。
(1) 這個Lambda沒有引數，並返回void。它類似於主體為空的方法：public void run() {}。
(2) 這個Lambda沒有引數，並返回String作為表示式。
(3) 這個Lambda沒有引數，並返回String（利用顯式返回語句）。
(4) return是一個控制流語句。要使此Lambda有效，需要使花括號，如下所示：
(Integer i) -> {return "Alan" + i;}。
(5)“Iron Man”是一個表示式，不是一個語句。要使此Lambda有效，你可以去除花括號
和分號，如下所示：(String s)
 
 -> "Iron Man"。或者如果你喜歡，可以使用顯式返回語
句，如下所示：(String s)->{return "IronMan";}。

這裡我們從一個排序問題入手——用不同的排序策略來給一個Apple列表排序，我們從一個原始粗暴的解決方法一步步簡明清晰化。

這裡會用到一系列概念：行為引數化，匿名類，Lambda表示式和方法引用。

下面是Apple類的定義：

    public static class Apple {
        private Integer weight = 0;
        private String color = "";

        public
 
 Apple(Integer weight, String color) {
            this.weight = weight;
            this.color = color;
        }

        public Integer getWeight() {
            return weight;
        }

        public void setWeight(Integer weight) {
            this.weight = weight;
        }

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public String toString() {
            return "Apple{" + "color='" + color + '\'' + ", weight=" + weight + '}';
        }
    }

第一步：傳遞程式碼

Java 8的API已經為我們提供了一個List可用的sort方法，我們不用自己去實現它。

那麼最困難的部分已經搞定了！但是，如何把排序策略傳遞給sort方法呢？
sort方法的簽名是這樣的：

void sort(Comparator<? super E> c)

它需要一個Comparator物件來比較兩個Apple！這就是在Java中傳遞策略的方式：它們必須包裹在一個物件裡。我們說sort的行為被引數化了：傳遞給它的排序策略不同，其行為也會不同。

List<Apple> inventory = new ArrayList<>();

public static class AppleComparator implements Comparator<Apple> {
        public int compare(Apple a1, Apple a2) {
            return a1.getWeight().compareTo(a2.getWeight());
        }
    }
inventory.sort(new AppleComparator());

第二步：使用匿名內部類

第一步的方案可以使用匿名內部類來進行優化，因為一個AppleComparator 比較器可能就使用一次，我們不需要單獨建立一個類來實現它。

        inventory.sort(new Comparator<Apple>() {
            public int compare(Apple a1, Apple a2) {
                return a1.getWeight().compareTo(a2.getWeight());
            }
        });

第三步：使用Lambda表示式

使用匿名內部類的缺點：
1.它往往很笨重，佔用了很多程式碼空間，換句話來說，它太囉嗦了。
2.用起來讓人費解，邏輯不是很清晰。
Java 8中引入了Lambda表示式，它提供了一種輕量級的語法來實現相同的目標：傳遞程式碼。（放在我們這個問題裡就是傳遞策略，List#sort()方法根據不同的策略（程式碼）來實現不同的排序）。
在這個例子中，Comparator代表了函式描述符(T, T) -> int。因為我們比較的是蘋果，所以它具體代表的就是(Apple, Apple) -> int。

inventory.sort((Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));

因為，Java編譯器可以根據Lambda出現的上下文來推斷出Lamdba表示式引數的型別，那麼我們的解決方案可以改寫為：

inventory.sort((a1, a2) -> a1.getWeight().compareTo(a2.getWeight()));

到這裡我們依舊不滿足，Comparator具有一個叫作comparing的靜態輔助方法，它可以接受一個Function來提取Comparable鍵值，並生成一個Comparator物件。

    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }

它可以像下面這樣用（注意你現在傳遞的Lambda只有一個引數：Lambda說明了如何從蘋果中提取需要比較的鍵值）：

Comparator<Apple> c = Comparator.comparing((Apple a) -> a.getWeight());
inventory.sort(c);

這裡我們還可以把程式碼改的緊湊一些：

// 靜態導包
import static java.util.Comparator.comparing;
inventory.sort(comparing((a) -> a.getWeight()));

第四步：使用方法引用

方法引用就是替代那些轉發引數的Lambda表示式的語法糖。你可以用方法引用讓你的程式碼更簡潔（假設你靜態匯入了java.util.Comparator.comparing）：

inventory.sort(comparing(Apple::getWeight));

方法引用讓你重複使用現有的方法實現並直接傳遞它們。

恭喜你，這就是你的最終解決方案！這比Java 8之前的程式碼好在哪兒呢？

它比較短；它的意思也很明顯，並且程式碼讀起來和問題描述差不多：“對庫存進行排序，比較蘋果的重量。”