Java8 函數式方法引用優秀實踐
一、詳解lambda中的方法引用
1. 方法引用使用的推導
我們現在有一個蘋果類，其代碼定義如下：
@Data
@AllArgsConstructor
public class Apple {
private int weight;
}因為重量單位的不同，所以得出的重量的結果可能是不同的，所以我們將計算重量的核心部分抽象成函數式接口，如下function所示，它要求我們傳入Apple返回Integer：
private static int getWeight(Apple apple, Function<Apple,Integer> function) {
return function.apply(apple);
}假設我們對重量無需任何單位換算即原原本本返回重量本身，那么我們的表達式則直接是(a)->a.getWeight()，對應代碼如下：
Apple apple=new Apple(1);
System.out.println(getWeight(apple,(a)->a.getWeight()));其實這個表達式還不是最精簡的，按照方法引用的語法糖，如果我們的lambda表達式符合：(arg)->arg.method()，即傳入的lambda就是(實例變量)->實例變量.實例方法()，那么這個表達式就可以直接縮寫為arg ClassName::invokeMethod：
于是我們的代碼就可以精簡成下面這樣：
System.out.println(getWeight(apple,Apple::getWeight));除了上述這個公式以外，其實還有另外兩種公式，如下所示我們的map映射希望將流中的字符串轉為整型，然后輸出：
Arrays.asList("1").stream()
.map(s -> Integer.parseInt(s))
.forEach(i -> System.out.println(i));按照jdk8的語法糖，對應的靜態類調用靜態方法的表達式(args)->className.staticMethod(args)可以直接縮寫為className->staticMethod(args)，于是我們的整型轉換的就可以直接縮寫為Integer::parseInt：
Arrays.asList("1").stream()
.map(Integer::parseInt)
.forEach(i -> System.out.println(i));最后一種則是針對多參數的如下所示，這是一個常規的排序lambda編程：
List<String> str = Arrays.asList("a","b","A","B");
str.sort((s1, s2) -> s1.compareToIgnoreCase(s2));按照Java8的語法糖：(arg1,arg2)->arg1.instanceMethod(arg2)可以直接轉換為arg1ClassName::invokeInstanceMethod，于是我們的就有了下面的推導：
最終我們的表達式就變成了這樣：
List<String> str = Arrays.asList("a","b","A","B");
str.sort(String::compareToIgnoreCase);2. 方法引用對于對象構造的抽象
實際上對象構造也可以通過方法引用表達，其整體縮寫的語法和靜態方法引用類似，如下圖所示本質上new的動作就可以直接理解為對于new的調用，同理簡寫為className::new來表達：
我們不妨結合幾個例子進行說明，如下便是蘋果對象的類定義，即帶有重量、顏色等屬性，同時支持含參或不含參的方式構造：
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Apple {
private int weight;
private String color;
}簡單的蘋果對象創建就像下面這樣new創建
//普通對象創建
Apple apple = new Apple();實際上這個創建步驟在函數式中可以抽象的理解為Supplier接口()->T，其中T為Apple，所以我們表達式可以轉換為如下方式：
Supplier<Apple> apply = () -> new Apple();
Apple apple1 = apply.get();此時，基于我們上述的圖解，即可將Supplier對象構造推導出構造函數的方法引用：
于是就有了下方代碼：
//采用方法引用縮寫
Supplier<Apple> apply2 = Apple::new;
Apple apple2 = apply2.get();我們再來一個難一點的例子，因為我們的構造器為傳參順序為weight、color然后創建Apple實例，對此我們可以大體抽象出函數式接口的簽名為(Integer,String)->Apple，基于這個簽名我們可以直接套用公式BiFunction，它的簽名為(T,U)->R，參數列表符合要求，我們直接將類型代入完成函數式接口抽象：
private static Apple createApple(Integer weight,String color,BiFunction<Integer, String, Apple> func) {
return func.apply(weight, color);
}基于上述的簽名的參數列表和預期返回值，我們得出下面這樣一條lambda表達式作為入參傳入，由此得到一個Apple實例：
createApple(1,"yellow",(w,s)->new Apple(w,s));按照上文所說的公式，于是我們的表達式又可以轉為方法引用：
對應的代碼如下所示：
createApple(1,"yellow",Apple::new);3. lambda和方法引用的結合
我們希望對蘋果類進行排序，對此我們給出蘋果類的實例集合：
List<Apple> appleList = Arrays.asList(new Apple(80, "green"),
new Apple(200, "red"),
new Apple(155, "yellow"),
new Apple(120, "red"));查看函數式接口Comparator的抽象方法 int compare(T o1, T o2);得出對應的函數簽名為(T,T)->Integer，代入我們的Apple類，那么這個比較器的函數描述符則是(Apple,Apple)->Integer，于是我們就有了下面這條lambda表達式：
Comparator<Apple> comparator = (a1,a2)->a1.getWeight()-a2.getWeight();我們鍵入如下代碼進行調用輸出：
appleList.sort(comparator);
appleList.forEach(System.out::println);和預期比較結果一致：
Apple(weight=80, color=green)
Apple(weight=120, color=red)
Apple(weight=155, color=yellow)
Apple(weight=200, color=red)實際上我們還可以做的更加精簡，因為JDK8中的Comparator已經為比較器提供了一個方法comparing，查看其源碼可以看到他要求傳入一個入參keyExtractor，從語義上就可以知道這個參數是作為比較的條件，以我們的例子就是Apple的weight。 這個keyExtractor是Function接口，查看其泛型我們也可以知曉它的函數式簽名為T->R，由此我們可以推理出該方法本質就是通過Function接口變量keyExtractor生成比較變量的實例然后調用compareTo進行比較并返回結果：
//要求傳入keyExtractor即作為比較的條件
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
Function<? super T, ? extends U> keyExtractor)
{
//......
return (Comparator<T> & Serializable)
//通過keyExtractor生成key值調用其compareTo方法進行比較
(c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
}基于上述分析我們就可以開始編寫這個比較器的keyExtractor的lambda表達式了，如下圖，通過keyExtractor泛型得出函數描述符為(T)->R，基于我們的場景推導出公式是apple實例->apple實例的weight，最后comparing會基于這個函數接口生成的R對象(我們的場景是weight即int類型)調用compareTo進行比較：
于是我們就有了這樣一條lambda表達式，但這還不是最精簡的：
Comparator<Apple> comparator = Comparator.comparing(a->a.getWeight());按照lambda的語法糖:instance->instance.method 可以直接轉為instanceType::method，我們最終的表達式如下，預期結果也和之前一致：
Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight);當然有時候我們希望能夠對結果進行反向排序，我們也只需在comparing方法后面加一個reversed即實現，從語義和使用上是不是都很方便呢？
Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight).reversed();二、復合表達式
1. 復合比較器
自此我們基本將方法引用的推導和使用都講完了，接下來我們還是基于lambda做一些實用的拓展，先來說說復合比較器，以上文的蘋果為例，假設我們希望當重量一樣時，在比較顏色進行進一步比較，那么我們就可以直接通過thenComparing生成復合表達式：
Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight).reversed().thenComparing(Apple::getColor);2. 謂詞復合
還是用上面的例子，我們希望根據不同的條件從蘋果集合中過濾出復合條件的蘋果，對此我們基于Predicate即斷言函數式接口編寫了一個filterApple方法：
private static List<Apple> filterApple(List<Apple> appleList, Predicate<Apple> predicate) {
List<Apple> list = new ArrayList<>();
for (Apple apple : appleList) {
//復合predicate設定條件的蘋果存入集合中
if (predicate.test(apple)) {
list.add(apple);
}
}
return list;
}假如客戶需要過濾出紅色的蘋果，基于predicate的簽名我們得出這樣一個表達式，這里就不多介紹了：
filterApple(appleList, apple -> apple.getColor().equals("red"));假如這時候我們有需要過濾出不為紅色的蘋果呢？其實JDK8為我們提供了一個非常強大的謂詞negate，我們完全可以基于上面的代碼進行改造從而實現需求，如下所示negate就相當于!"red".equals(a.getColor());，語義是不是很清晰呢？
Predicate<Apple> predicate = apple -> apple.getColor().equals("red");
filterApple(appleList, predicate.negate());但是我們需要再次變化了，我們希望找出紅色且重量大于150，或者顏色為綠色的蘋果，這時候又怎么辦呢？我們說過JDK8提供了and、or等謂詞，我們的代碼完全可以寫成下文所示,可以看到代碼語義以及流暢度都相比JDK8之前的各種&& ||拼接for循環來說優雅非常多：
//過濾出紅色的蘋果
Predicate<Apple> predicate = apple -> apple.getColor().equals("red");
//過濾出紅色且大于150 或者綠色的蘋果
Predicate<Apple> redAndHeavyAppleOrGreen = predicate.and(apple -> apple.getWeight() > 150).
or(apple -> apple.getColor().equals("green"));
filterApple(appleList, redAndHeavyAppleOrGreen);3. 函數復合
我們都說代碼和數學息息相關，其實java8也提供很多函數式接口可以運用于數學公式上,例如，我們現在需要計算f(g(x))，這個公式學過高數的同學都知道，是先計算g(x)再將g(x)的結果作為入參交給f(x)計算，對應題解案例如下：
我們假設g(x)=x * 2
f(x)=x+1
假如x=1
那么g(f(x))最終就會等于4了解數學公式之后，我們完全可以使用java代碼表示出來，首先我們先聲明一下f(x)和g(x)：
//f(x)
Function<Integer, Integer> f = x -> x + 1;
//g(x)
Function<Integer, Integer> g = x -> x * 2;在表示g(f(x))，通過復合表達式andThen表達了數學的計算順序，即顯得出f(x)結果，然后(andThen)代入g(x)中：
//意味先計算f(x)在計算g(x)
Function<Integer, Integer> h = f.andThen(g);
System.out.println(result); //輸出 4基于上面的例子，如果我們還需要計算f(g(x))要怎么辦呢？從f(x)角度來看，g(x)的結果組合到f(x)上，所以我們可以直接實用compose方法：
Function<Integer, Integer> fgx = f.compose(g);
Integer result = fgx.apply(1);
System.out.println(result);// 輸出 3其實,按照奧卡姆剃刀守則，如果按照筆者的習慣，會優先使用第一種，即fg(x)用 g.andThen(f);,即先算g再算f,而gf(x)則用f.andThen(g);即先算f再算g。
