概述

在Java 8之前，我們通常會為每種需要封裝單個功能的情況創(chuàng)建一個類，這意味著需要大量不必要的樣板代碼。

Java 8以Lambda表達式的形式帶來了一個強大的新語法改進，Lambda是一個匿名函數(shù)。

Function接口

建議所有函數(shù)接口都使用@FunctionalInterface注解，用于清楚傳達函數(shù)接口的目的，并且還允許編譯器在帶有該注解的接口，在不滿足條件的情況下生成編譯錯誤。

任何帶有SAM（單一抽象方法）的接口都是函數(shù)接口，被視為Lambda表達式。

Java8 的默認方法不是抽象的，也不算在內(nèi)，函數(shù)接口允許存在多個默認方法。

Lambda最簡單、最通用的情況是一個函數(shù)接口，該接口具有一個接收一個值并返回另一個值的方法。單個參數(shù)的函數(shù)可以由Function接口表示，該接口通過其參數(shù)的類型和返回值進行參數(shù)化：

public interface Function<T, R> { … }

Function類型在標準JDK庫中的用法之一是Map.computeIfAbsent方法。此方法按鍵返回映射中的值，但如果映射中尚未存在鍵，則會計算值。要計算一個值，它使用傳遞的Function實現(xiàn)：

Map<String, Integer> nameMap = new HashMap<>();
Integer value = nameMap.computeIfAbsent("John", s -> s.length());

Function接口還有一個默認的compose方法，它允許我們將多個函數(shù)組合為一個函數(shù)并按順序執(zhí)行：

Function<Integer, String> intToString = Object::toString;
Function<String, String> quote = s -> "'" + s + "'";

Function<Integer, String> quoteIntToString = quote.compose(intToString);

assertEquals("'5'", quoteIntToString.apply(5));

基元類型函數(shù)

由于基元類型不能是泛型類型參數(shù)，因此對于最常用的基元類型double、int、long及其在參數(shù)和返回類型中的組合，函數(shù)接口有以下版本：

• IntFunction、LongFunction、DoubleFunction：參數(shù)是指定類型的，返回類型是參數(shù)化的
• ToIntFunction、ToLongFunction、ToDoubleFunction：返回類型為指定類型，參數(shù)是參數(shù)化的
• DoubleToIntFunction、DoubleToLongFunction、IntToDoubleFunction、IntToLongFunction、LongToIntFunction和LongToDoubleFunction：參數(shù)和返回類型都定義為基元類型，由它們的名稱指定

例如，對于一個使用short并返回字節(jié)的函數(shù)：

@FunctionalInterface
public interface ShortToByteFunction {

    byte applyAsByte(short s);

}

現(xiàn)在，我們可以編寫一個方法，使用ShortToByteFunction定義的規(guī)則將short數(shù)組轉(zhuǎn)換為字節(jié)數(shù)組：

public byte[] transformArray(short[] array, ShortToByteFunction function) {
    byte[] transformedArray = new byte[array.length];
    for (int i = 0; i < array.length; i++) {
        transformedArray[i] = function.applyAsByte(array[i]);
    }
    return transformedArray;
}

以下是我們?nèi)绾问褂盟鼘hort數(shù)組轉(zhuǎn)換為字節(jié)乘以2的數(shù)組：

short[] array = {(short) 1, (short) 2, (short) 3};
byte[] transformedArray = transformArray(array, s -> (byte) (s * 2));

byte[] expectedArray = {(byte) 2, (byte) 4, (byte) 6};
assertArrayEquals(expectedArray, transformedArray);

Bi函數(shù)接口

要用兩個參數(shù)定義lambda，我們必須使用名稱中包含“Bi”關鍵字的附加接口：BiFunction、ToDoubleBiFunction、ToIntBiFunction和ToLongBiFunction。

BiFunction同時生成了參數(shù)和返回類型，而ToDoubleBiFunction和其他函數(shù)允許我們返回基元值。

在標準API中使用此接口的典型示例之一是Map.replaceAll方法，它允許用一些計算值替換Map中的所有值。

讓我們使用一個BiFunction實現(xiàn)，該實現(xiàn)接收一個鍵和一個舊值來計算工資的新值并返回。

Map<String, Integer> salaries = new HashMap<>();
salaries.put("John", 40000);
salaries.put("Freddy", 30000);
salaries.put("Samuel", 50000);

salaries.replaceAll((name, oldValue) -> 
  name.equals("Freddy") ? oldValue : oldValue + 10000);

Suppliers函數(shù)接口

通常用它來提供數(shù)據(jù)產(chǎn)出，例如，讓我們定義一個函數(shù)，它將一個值平方：

public double squareLazy(Supplier<Double> lazyValue) {
    return Math.pow(lazyValue.get(), 2);
}

Supplier<Double> lazyValue = () -> {
    Uninterruptibles.sleepUninterruptibly(1000, TimeUnit.MILLISECONDS);
    return 9d;
};

Double valueSquared = squareLazy(lazyValue);

讓我們使用一個靜態(tài)Stream.generate方法來創(chuàng)建一個Fibonacci數(shù)字流：

int[] fibs = {0, 1};
Stream<Integer> fibonacci = Stream.generate(() -> {
    int result = fibs[1];
    int fib3 = fibs[0] + fibs[1];
    fibs[0] = fibs[1];
    fibs[1] = fib3;
    return result;
});

我們使用一個數(shù)組而不是兩個變量，因為lambda內(nèi)部使用的所有外部變量都必須是有效的final。

Consumers函數(shù)接口

例如，讓我們通過在控制臺中打印問候語來問候姓名列表中的每個人。傳遞給List.forEach方法的lambda實現(xiàn)了Consumer函數(shù)接口：

List<String> names = Arrays.asList("John", "Freddy", "Samuel");
names.forEach(name -> System.out.println("Hello, " + name));

還有專門版本的Consumer（DoubleConsumer、IntConsumer和LongConsumer），它們接收基元值作為參數(shù)：

Map<String, Integer> ages = new HashMap<>();
ages.put("John", 25);
ages.put("Freddy", 24);
ages.put("Samuel", 30);

ages.forEach((name, age) -> System.out.println(name + " is " + age + " years old"));

另一組專門的BiConsumer版本由ObjDoubleConsumer、ObjIntConsumer和ObjLongConsumer組成，它們接收兩個參數(shù)；其中一個參數(shù)是泛型的，另一個是基元類型。

Predicates函數(shù)接口

Predicates是一個接收值并返回布爾值的函數(shù)。

List<String> names = Arrays.asList("Angela", "Aaron", "Bob", "Claire", "David");

List<String> namesWithA = names.stream()
  .filter(name -> name.startsWith("A"))
  .collect(Collectors.toList());

在上面的代碼中，我們使用流API過濾列表，并只保留以字母“a”開頭的名稱。Predicates實現(xiàn)封裝了篩選邏輯。

與前面的所有示例一樣，此函數(shù)的IntPredicate、DoublePredicate和LongPredicate版本都接收基元值。

Operators函數(shù)接口

Operator接口是接收和返回相同值類型的函數(shù)的特殊情況。UnaryOperator接口接收一個參數(shù)。它在集合API中的一個用例是用相同類型的一些計算值替換列表中的所有值：

List<String> names = Arrays.asList("bob", "josh", "megan");
names.replaceAll(name -> name.toUpperCase());

當然，我們可以簡單地使用方法引用來代替name->name.toUpperCase（）：

names.replaceAll(String::toUpperCase);

BinaryOperator最有趣的用例之一是歸約運算。假設我們想將一組整數(shù)聚合為所有值的總和。使用流API，我們可以使用收集器來實現(xiàn)這一點，但更通用的方法是使用reduce方法：

List<Integer> values = Arrays.asList(3, 5, 8, 9, 12);

int sum = values.stream()
  .reduce(0, (i1, i2) -> i1 + i2);

reduce方法接收一個初始累加器值和一個BinaryOperator函數(shù)。此函數(shù)的參數(shù)是一對相同類型的值；函數(shù)本身還包含一個邏輯，用于將它們連接到同一類型的單個值中。傳遞的函數(shù)必須是關聯(lián)的，這意味著值聚合的順序無關緊要，即應滿足以下條件：

op.apply(a, op.apply(b, c)) == op.apply(op.apply(a, b), c)

其他

并不是所有的功能接口都出現(xiàn)在Java 8中。以前版本的Java中的許多接口都符合FunctionalInterface的約束，我們可以將它們用作lambda。

突出的例子包括并發(fā)API中使用的Runnable和Callable接口。在Java 8中，這些接口也用@FunctionalInterface注釋進行標記。這使我們能夠極大地簡化并發(fā)代碼：

Thread thread = new Thread(() -> System.out.println("Hello From Another Thread"));
thread.start();

結論

本文主要演示了Java 8 API中的不同功能的函數(shù)接口，這些接口可以用作Lambda表達式。函數(shù)式流式編程方法在Java 8 之后的項目中應用非常普遍。