Java8 新語法習慣 (級聯 lambda 表達式)

在函數式編程中，函數既能夠接收也能夠返回其餘函數。函數不在像傳統的面向對象編程同樣，只是一個對象的工廠或生成器，它也可以建立和返回另外一個函數。返回函數的函數能夠變成級聯 lambda 表達式，代碼很是短。儘管這樣的語法初次看起來很是的陌生，可是它有本身的用途。本文將幫助您認識級聯 lambda 表達式，理解它們的性質和在代碼中的用途。

神祕的語法

看下面的一端代碼：

x -> y -> x > y
複製代碼

對於不熟悉使用 lambda 表達式編程的開發人員，此語法可能看起來像貨物正在從快速行駛的卡車上一件件掉下來。這很是的使人感到好奇。幸運的是咱們不會常常看到他們，但理解如何建立級聯 lambda 表達式和如何在代碼中理解它們會是頗有好處的。

高階函數

在談論級聯 lambda 表達式以前，有必要首先理解如何建立它們。對此，咱們須要回顧一下高階函數和它們在函數分解中的做用，函數分解是一種將複雜流程分解爲更小、更簡單的部分的方式。

首先區分一下高階函數和常規函數的規則：

常規函數

• 能夠接收對象
• 能夠建立對象
• 能夠返回對象

高階函數

• 能夠接收函數
• 能夠建立函數
• 能夠返回函數

開發人員能夠將匿名函數或 lambda 表達式傳遞給高階函數，以讓代碼簡短且富於表達。讓咱們看看這個高階函數的兩個示例。

一個接收函數的函數

在 Java 中，咱們使用函數接口引用 lambda 表達式和方法引用。下面這個函數接收一個對象和一個函數：

public static int totalSelectedValues(List<Integer> values, Predicate<Integer> selector) {

  return values.stream()
    .filter(selector)
    .reduce(0, Integer::sum);  
}
複製代碼

totalSelectedValues 的第一個參數是集合對象，而第二個參數是 Predicate 函數接口。 由於參數類型是函數接口 (Predicate)，因此咱們如今能夠將一個 lambda 表達式做爲第二個參數傳遞給 totalSelectedValues。例如，若是咱們想僅對一個 numbers 列表中的偶數值求和，能夠調用 totalSelectedValues，以下所示：

totalSelectedValues(numbers, e -> e % 2 == 0);
複製代碼

假設咱們如今在 Util 類中有一個名爲 isEven 的 static 方法。在此狀況下，咱們可使用 isEven 做爲 totalSelectedValues 的參數，而不傳遞 lambda 表達式：

totalSelectedValues(numbers, Util::isEven);
複製代碼

做爲規則，只要一個函數接口顯示爲一個函數的參數的類型，您看到的就是一個高階函數

一個返回函數的函數

函數能夠接收函數、lambda 表達式或方法引用做爲參數。一樣的，函數也能夠返回 lambda 表達式或方法引用。在此狀況下，返回類型將是函數接口。

讓咱們首先看一個建立並返回 Predicate 來驗證給定值是否爲奇數的函數：

public static Predicate<Integer> createIsOdd() {
  Predicate<Integer> check = (Integer number) -> number % 2 != 0;
  return check;
}
複製代碼

爲了返回一個函數，咱們必須提供一個函數接口做爲返回類型。在本例中，咱們的函數接口是 Predicate。儘管上述代碼在語法上是正確的，但它能夠更加簡短。 咱們使用類型引用並刪除臨時變量來改進該代碼：

public static Predicate<Integer> createIsOdd() {
  return number -> number % 2 != 0;
}
複製代碼

這是使用的 createIsOdd 方法的一個示例：

Predicate<Integer> isOdd = createIsOdd();

isOdd.test(4);
複製代碼

建立可重用的函數

如今已經大致瞭解高階函數和如何在代碼中找到他們，咱們能夠考慮使用他們來讓代碼更加簡短。

設想咱們有兩個列表 numbers1 和 numbers2。假設咱們想從第一個列表中僅提取大於 50 的數，而後從第二個列表中提取大於 50 的值並乘以 2。

List<Integer> result1 = numbers1.stream()
  .filter(e -> e > 50)
  .collect(toList());

List<Integer> result2 = numbers2.stream()
  .filter(e -> e > 50)
  .map(e -> e * 2)
  .collect(toList());
複製代碼

此代碼很好，但您注意到它很冗長了嗎？咱們對檢查數字是否大於 50 的 lambda 表達式使用了兩次。 咱們能夠經過建立並重用一個 Predicate，從而刪除重複代碼，讓代碼更富於表達：

Predicate<Integer> isGreaterThan50 = number -> number > 50;

List<Integer> result1 = numbers1.stream()
  .filter(isGreaterThan50)
  .collect(toList());

List<Integer> result2 = numbers2.stream()
  .filter(isGreaterThan50)
  .map(e -> e * 2)
  .collect(toList());
複製代碼

經過將 lambda 表達式存儲在一個引用中，咱們能夠重用它，這是咱們避免重複 lambda 表達式的方式。若是咱們想跨方法重用 lambda 表達式，也能夠將該引用放入一個單獨的方法中，而不是放在一個局部變量引用中。

如今假設咱們想從列表 numbers1 中提取大於 2五、50 和 75 的值。咱們能夠首先編寫 3 個不一樣的 lambda 表達式：

List<Integer> valuesOver25 = numbers1.stream()
  .filter(e -> e > 25)
  .collect(toList());

List<Integer> valuesOver50 = numbers1.stream()
  .filter(e -> e > 50)
  .collect(toList());

List<Integer> valuesOver75 = numbers1.stream()
  .filter(e -> e > 75)
  .collect(toList());
複製代碼

儘管上面每一個 lambda 表達式將輸入與一個不一樣的值比較，但它們作的事情徹底相同。如何以較少的重複來重寫此代碼？

建立和重用 lambda 表達式

儘管上一個示例中的兩個 lambda 表達式相同，但上面 3 個表達式稍微不一樣。建立一個返回 Predicate 的 Function 能夠解決此問題。

首先，函數接口 Function<T, U> 將一個 T 類型的輸入轉換爲 U 類型的輸出。例如，下面的示例將一個給定值轉換爲它的平方根：

Function<Integer, Double> sqrt = value -> Math.sqrt(value);
複製代碼

在這裏，返回類型 U 能夠很簡單，好比 Double、String 或 Person。或者它也能夠更復雜，好比 Consumer 或 Predicate 等另外一個函數接口

在本例中，咱們但願一個 Function 建立一個 Predicate。因此代碼以下：

Function<Integer, Predicate<Integer>> isGreaterThan = (Integer pivot) -> {
  Predicate<Integer> isGreaterThanPivot = (Integer candidate) -> {
    return candidate > pivot;
  };

  return isGreaterThanPivot;
};
複製代碼

引用 isGreaterThan 引用了一個表示 Function<T, U> 或更準確地講表示 Function<Integer, Predicate<Integer>> 的 lambda 表達式。輸入是一個 Integer，輸出是一個 Predicate<Integer>。在 lambda 表達式的主體中（外部 {} 內），咱們建立了另外一個引用 isGreaterThanPivot，它包含對另外一個 lambda 表達式的引用。這一次，該引用是一個 Predicate 而不是 Function。最後，咱們返回該引用。

isGreaterThan 是一個 lambda 表達式的引用，該表達式在調用時返回另外一個 lambda 表達式 — 換言之，這裏隱藏着一種 lambda 表達式級聯關係。

如今，咱們可使用新建立的外部 lamba 表達式來解決代碼中的重複問題：

List<Integer> valuesOver25 = numbers1.stream()
  .filter(isGreaterThan.apply(25))
  .collect(toList());

List<Integer> valuesOver50 = numbers1.stream()
  .filter(isGreaterThan.apply(50))
  .collect(toList());

List<Integer> valuesOver75 = numbers1.stream()
  .filter(isGreaterThan.apply(75))
  .collect(toList());
複製代碼

在 isGreaterThan 上調用 apply 會返回一個 Predicate，後者而後做爲參數傳遞給 filter 方法。

保持簡單的祕訣

咱們已從代碼中成功刪除了重複的 lambda 表達式，但 isGreaterThan 的定義看起來仍然很雜亂。幸運的是，咱們能夠組合一些 Java 8 約定來減小雜亂，讓代碼更簡短。

可使用類型引用來從外部和內部 lambda 表達式的參數中刪除類型細節：

Function<Integer, Predicate<Integer>> isGreaterThan = (pivot) -> {
  Predicate<Integer> isGreaterThanPivot = (candidate) -> {
    return candidate > pivot;
  };

  return isGreaterThanPivot;
};
複製代碼

接下來，咱們刪除多餘的 ()，以及外部 lambda 表達式中沒必要要的臨時引用：

Function<Integer, Predicate<Integer>> isGreaterThan = pivot -> {
  return candidate -> {
    return candidate > pivot;
  };
};
複製代碼

能夠看到內部 lambda 表達式的主體只有一行，顯然 {} 和 return 是多餘的。讓咱們刪除它們：

Function<Integer, Predicate<Integer>> isGreaterThan = pivot -> {
  return candidate -> candidate > pivot;
};
複製代碼

如今能夠看到，外部 lambda 表達式的主體也只有一行，因此 {} 和 return 在這裏也是多餘的。在這裏，咱們應用最後一次重構：

Function<Integer, Predicate<Integer>> isGreaterThan =
  pivot -> candidate -> candidate > pivot;
複製代碼

如今能夠看到 — 這是咱們的級聯 lambda 表達式。

理解級聯 lambda 表達式

咱們經過一個適合每一個階段的重構過程，獲得了最終的代碼 - 級聯 lambda 表達式。在本例中，外部 lambda 表達式接收 pivot 做爲參數，內部 lambda 表達式接收 candidate 做爲參數。內部 lambda 表達式的主體同時使用它收到的參數 (candidate) 和來自外部範圍的參數。也就是說，內部 lambda 表達式的主體同時依靠它的參數和它的詞法範圍或定義範圍。

大致上講，當您看到兩個向右箭頭時，能夠將第一個箭頭右側的全部內容視爲一個黑盒：一個由外部 lambda 表達式返回的 lambda 表達式。

總結

級聯 lambda 表達式不是很常見，但您應該知道如何在代碼中識別和理解它們。當一個 lambda 表達式返回另外一個 lambda 表達式，而不是接受一個操做或返回一個值時，您將看到兩個箭頭。

感謝 Venkat Subramaniam 博士

Venkat Subramaniam 博士站點：http://agiledeveloper.com/ 知識改變生活，努力改變生活