摘要：編程語言將函數作為一等公民，函數可以被作為參數或者返回值傳遞，因為它被視為對象。是表示已注釋接口是函數接口的注釋。如果一個函數有一個或多個參數并且有返回值呢為了解決這個問題，提供了一系列通用函數接口，在包里。

【編者按】雖然 Java 深得大量開發者喜愛，但是對比其他現代編程語言，其語法確實略顯冗長。但是通過 Java8，直接利用 lambda 表達式就能編寫出既可讀又簡潔的代碼。作者 Hussachai Puripunpinyo 的軟件工程師，作者通過對比 Java 8和 Scala，對性能和表達方面的差異進行了分析，并且深入討論關于 Stream API 的區別，本文由 OneAPM 工程師編譯整理。

數年等待，Java 8 終于添加了高階函數這個特性。本人很喜歡 Java，但不得不承認，相比其他現代編程語言，Java 語法非常冗長。然而通過 Java8，直接利用 lambda 表達式就能編寫出既可讀又簡潔的代碼（有時甚至比傳統方法更具可讀性）。

Java 8于2014年3月3日發布，但筆者最近才有機會接觸。因為筆者也很熟悉 Scala，所以就產生了對比 Java 8和Scala 在表達性和性能方面的差異，比較將圍繞 Stream API 展開，同時也會介紹如何使用 Stream API 來操作集合。

由于文章太長，所以分以下三個部分詳細敘述。

Part 1.Lambda 表達式

Part 2. Stream API vs Scala collection API

Part 3. Trust no one, bench everything(引用自sbt-jmh)

首先，我們來了解下 Java 8的 lambda 表達式，雖然不知道即使表達式部分是可替代的，他們卻稱之為 lambda 表達式。這里完全可以用聲明來代替表達式，然后說 Java 8還支持 lambda 聲明。編程語言將函數作為一等公民，函數可以被作為參數或者返回值傳遞，因為它被視為對象。Java是一種靜態的強類型語言。所以，函數必須有類型，因此它也是一個接口。

另一方面，lambda 函數就是實現了函數接口的一個類。無需創建這個函數的類，編譯器會直接實現。不幸的是，Java 沒有 Scala 那樣高級的類型接口。如果你想聲明一個 lambda 表達式，就必須指定目標類型。實際上，由于 Java 必須保持向后兼容性，這也是可理解的，而且就目前來說 Java 完成得很好。例如，Thread.stop() 在 JDK 1.0版時發布，已過時了十多年，但即便到今天仍然還在使用。所以，不要因為語言 XYZ 的語法（或方法）更好，就指望 Java 從根本上改變語法結構。

所以，Java 8的語言設計師們奇思妙想，做成函數接口！函數接口是只有一個抽象方法的接口。要知道，大多數回調接口已經滿足這一要求。因此，我們可以不做任何修改重用這些接口。@FunctionalInterface 是表示已注釋接口是函數接口的注釋。此注釋是可選的，除非有檢查要求，否則不用再進行處理。

請記住，lambda 表達式必須定義類型，而該類型必須只有一個抽象方法。

</>復制代碼 
//Before Java 8
Runnable r = new Runnable(){  
  public void run(){    
    System.out.println(“This should be run in another thread”);  
  }
};
//Java 8
Runnable r = () -> System.out.println(“This should be run in another thread”);

如果一個函數有一個或多個參數并且有返回值呢？為了解決這個問題，Java 8提供了一系列通用函數接口，在java.util.function包里。

</>復制代碼 
//Java 8
Function parseInt = (String s) -> Integer.parseInt(s);

該參數類型可以從函數中推斷，就像 Java7中的diamond operator，所以可以省略。我們可以重寫該函數，如下所示：

</>復制代碼 
//Java 8
Function parseInt = s -> Integer.parseInt(s);

如果一個函數有兩個參數呢？無需擔心，Java 8 中有 BiFunction。

</>復制代碼 
//Java 8
BiFunction multiplier = 
  (i1, i2) -> i1 * i2; //you can’t omit parenthesis here!

如果一個函數接口有三個參數呢？TriFunction？語言設計者止步于 BiFunction。否則，可能真會有 TriFunction、quadfunction、pentfunction 等。解釋一下，筆者是采用 IUPAC 規則來命名函數的。然后，可以按如下所示定義 TriFunction。

</>復制代碼 
//Java 8
@FunctionalInterface
interface TriFunction {  
  public R apply(A a, B b, C c);
}

然后導入接口，并把它當作 lambda 表達式類型使用。

</>復制代碼 
//Java 8
TriFunction sumOfThree 
  = (i1, i2, i3) -> i1 + i2 + i3;

這里你應該能理解為什么設計者止步于 BiFunction。

如果還沒明白，不妨看看 PentFunction，假設我們在其他地方已經定義了 PentFunction。

</>復制代碼 
//Java 8
PentFunction 
  sumOfFive = (i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5;

你知道 Ennfunction 是多長嗎？（拉丁語中，enn 表示9）你必須申報 10 種類型（前 9 個是參數，最后一個是返回類型），大概整行都只有類型了。那么聲明一個類型是否有必要呢？答案是肯定的。（這也是為什么筆者認為 Scala 的類型接口比 Java 的更好）

Scala 也有其 lambda 表達式類型。在 Scala 中，你可以創建有22個參數的 lambda 表達式，意味著 Scala 有每個函數的類型（Function0、Function1、……Function22）。函數類型在 Scala 函數中是一個 Trait，Trait 就像 Java 中的抽象類，但可以當做混合類型使用。如果還需要22個以上的參數，那大概是你函數的設計有問題。必須要考慮所傳遞的一組參數的類型。在此，筆者將不再贅述關于 Lambda 表達式的細節。

下面來看看Scala的其他內容。Scala 也是類似 Java 的靜態強類型語言，但它一開始就是函數語言。因此，它能很好地融合面向對象和函數編程。由于 Scala 和 Java 所采用的方法不同，這里不能給出 Runnable 的 Scala 實例。Scala 有自己解決問題的方法，所以接下來會詳細探討。

//Scala
Future(println{“This should be run in another thread”})

與以下 Java8 的代碼等效。

//Java 8
//assume that you have instantiated ExecutorService beforehand.
Runnable r = () -> System.out.println(“This should be run in another thread”);
executorService.submit(r);

如果你想聲明一個 lambda 表達式，可以不用像 Java 那樣聲明一個顯式類型。

</>復制代碼 
//Java 8
Function parseInt = s -> Integer.parseInt(s);
//Scala
val parseInt = (s: String) => s.toInt
//or
val parseInt:String => Int = s => s.toInt
//or
val parseInt:Function1[String, Int] = s => s.toInt

所以，在 Scala 中的確有多種辦法來聲明類型。讓編譯器來執行。那么 PentFunction 呢？

</>復制代碼 
//Java 8
PentFunction sumOfFive 
  = (i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5;
//Scala
val sumOfFive = (i1: Int, i2: Int, i3: Int, i4: Int, i5: Int) => 
  i1 + i2 + i3 + i4 + i5;

Scala 更短，因為不需要聲明接口類型，而整數類型在 Scala 中是 int。短不總意味著更好。Scala 的方法更好，不是因為短，而是因為更具可讀性。類型的上下文在參數列表中，可以很快找出參數類型。如果還不確定，可以再參考以下代碼。

</>復制代碼 
//Java 8
PentFunction 
  sumOfFive = (i1, i2, i3, i4, i5) -> i1 + i2 + i3 + i4 + i5;
//Scala
val sumOfFive = (i1: String, i2: Int, i3: Double, i4: Boolean, i5: String) 
=> i1 + i2 + i3 + i4 + i5;

在 Scala 中，可以很明確地說出 i3 類型是 Double 型，但在 Java 8 中，還需要算算它是什么類型。你可能爭辯說 Java 也可以，但出現這樣的狀況：

</>復制代碼 
//Java 8
PentFunction sumOfFive 
  = (Integer i1, String i2, Integer i3, Double i4, Boolean i5) 
  -> i1 + i2 + i3 + i4 + i5;

你必須一遍又一遍的重復下去。

除此之外，Java8 并沒有 PentFunction，需要自己定義。

</>復制代碼 
//Java 8
@FunctionalInterface
interface PentFunction {  
  public R apply(A a, B b, C c, D d, E e);
}

是不是意味著 Scala 就更好呢？在某些方面的確是。但也有很多地方 Scala 不如 Java。所以很難說到底哪種更好，我之所以對兩者進行比較，是因為 Scala 是一種函數語言，而 Java 8 支持一些函數特點，所以得找函數語言來比較。由于 Scala 可以運行在 JVM 上，用它來對比再好不過。可能你會在使用函數時，Scala 有更簡潔的語法和方法，這是因為它本來就是函數語言，而 Java 的設計者在不破壞之前的基礎上拓展設計，顯然會有更多限制。

盡管 Java在語法上與 lambda 表達式相比有一定局限性，但 Java8 也引進了一些很酷的功能。例如，利用方法引用的特性通過重用現有方法使得編寫 lambda 表達式更簡潔。更簡潔嗎？？？

</>復制代碼 
//Java 8
Function parseInt = s -> Integer.parseInt(s);

可以使用方法引用來重寫函數，如下所示

</>復制代碼 
//Java 8
Function parseInt = Integer::parseInt;

還可以通過實例方法來使用方法引用。之后會在第二部分的 Stream API 中指出這種方法的可用性。

方法引用的構造規則

1.(args) -> ClassName.staticMethod(args);

可以像這樣重寫ClassName::staticMethod;

Function intToStr = String::valueOf;

2.(instance, args) -> instance.instanceMethod(args);

可以像這樣重寫 ClassName::instanceMethod；

BiFunction indexOf = String::indexOf;

3.(args) -> expression.instanceMethod(args);

可以像這樣重寫 expression::instanceMethod；

FunctionindexOf = new String()::indexOf;

你有沒有注意到規則2有點奇怪？有點混亂？盡管 indexOf 函數只需要1個參數，但 BiFunction 的目標類型是需要2個參數。其實，這種用法通常在 Stream API 中使用，當看不到類型名時才有意義。

</>復制代碼 
pets.stream().map(Pet::getName).collect(toList());
// The signature of map() function can be derived as
//  Stream map(Function mapper)

從規則3中，你可能會好奇能否用 lambda 表達式替換 new String()?

你可以用這種方法構造一個對象

Supplier str =String::new;

那么可以這樣做嗎?

Function,Integer> indexOf = (String::new)::indexOf;

不能。它不能編譯，編譯器會提示The target type of this expression must be a functional interface。錯誤信息很容易引起誤解，而且似乎 Java 8通過泛型參數并不支持類型接口。即使使用一個 Functionalinterface 的實例（如前面提到的「STR」），也會出現另一個錯誤The type Supplier does not define indexOf(Supplier) that is applicable here。String::new 的函數接口是 Supplier，而且它只有方法命名為 get()。indexOf 是一個屬于 String 對象的實例方法。因此，必須重寫這段代碼，如下所示。

</>復制代碼 
//Java
Function indexOf =          ((Supplier)String::new).get()::indexOf;

Java 8 是否支持 currying (partial function)？

的確可行，但你不能使用方法引用。你可以認為是一個 partial 函數，但是它返回的是函數而不是結果。接著將要介紹使用 currying 的簡單實例，但這個例子也可能行不通。在傳遞到函數之前，我們通常進行參數處理。但無論如何，先看看如何利用 lambda 表達式實現 partial 函數。假設你需要利用 currying 實現兩個整數相加的函數。

</>復制代碼 
//Java
IntFunctionadd = a -> b -> a + b;
add.apply(2).applyAsInt(3);//the result is 4! I"m kidding it"s 5.

該函數可以同時采用兩個參數。

</>復制代碼 
//Java
Supplier> add = () -> (a, b) -> a + b;
add.get().apply(2, 3);

現在，可以看看 Scala 方法。

</>復制代碼 
//Scala
val add = (a: Int) => (b:Int) => a + b
add(1)(2)
//Scala
val add = () => (a: Int,b: Int) => a + b
add2()(1,2)

因為類型引用和語法糖，Scala 的方法比 Java 更簡短。在 Scala 中，你不需要在 Function trait 上調用 apply 方法，編譯器會即時地將()轉換為 apply 方法。

原文鏈接： https://dzone.com/articles/java-8-λe-vs-scalapart-i

OneAPM for Java 能夠深入到所有 Java 應用內部完成應用性能管理和監控，包括代碼級別性能問題的可見性、性能瓶頸的快速識別與追溯、真實用戶體驗監控、服務器監控和端到端的應用性能管理。想閱讀更多技術文章，請訪問 OneAPM 官方博客。