一、詳解lambda中的方法引用

1. 方法引用使用的推導(dǎo)

我們現(xiàn)在有一個(gè)蘋(píng)果類，其代碼定義如下：

@Data
@AllArgsConstructor
public class Apple  {
    private int weight;
    
}

因?yàn)橹亓繂挝坏牟煌?，所以得出的重量的結(jié)果可能是不同的，所以我們將計(jì)算重量的核心部分抽象成函數(shù)式接口，如下function所示，它要求我們傳入Apple返回Integer：

private static int getWeight(Apple apple, Function<Apple,Integer> function) {
        return function.apply(apple);
    }

假設(shè)我們對(duì)重量無(wú)需任何單位換算即原原本本返回重量本身，那么我們的表達(dá)式則直接是(a)->a.getWeight()，對(duì)應(yīng)代碼如下：

Apple apple=new Apple(1);
 System.out.println(getWeight(apple,(a)->a.getWeight()));

其實(shí)這個(gè)表達(dá)式還不是最精簡(jiǎn)的，按照方法引用的語(yǔ)法糖，如果我們的lambda表達(dá)式符合：(arg)->arg.method()，即傳入的lambda就是(實(shí)例變量)->實(shí)例變量.實(shí)例方法()，那么這個(gè)表達(dá)式就可以直接縮寫(xiě)為arg ClassName::invokeMethod：

于是我們的代碼就可以精簡(jiǎn)成下面這樣：

System.out.println(getWeight(apple,Apple::getWeight));

除了上述這個(gè)公式以外，其實(shí)還有另外兩種公式，如下所示我們的map映射希望將流中的字符串轉(zhuǎn)為整型，然后輸出：

Arrays.asList("1").stream()
                .map(s -> Integer.parseInt(s))
                .forEach(i -> System.out.println(i));

按照jdk8的語(yǔ)法糖，對(duì)應(yīng)的靜態(tài)類調(diào)用靜態(tài)方法的表達(dá)式(args)->className.staticMethod(args)可以直接縮寫(xiě)為className->staticMethod(args)，于是我們的整型轉(zhuǎn)換的就可以直接縮寫(xiě)為Integer::parseInt：

Arrays.asList("1").stream()
                .map(Integer::parseInt)
                .forEach(i -> System.out.println(i));

最后一種則是針對(duì)多參數(shù)的如下所示，這是一個(gè)常規(guī)的排序lambda編程：

List<String> str = Arrays.asList("a","b","A","B");
str.sort((s1, s2) -> s1.compareToIgnoreCase(s2));

按照J(rèn)ava8的語(yǔ)法糖：(arg1,arg2)->arg1.instanceMethod(arg2)可以直接轉(zhuǎn)換為arg1ClassName::invokeInstanceMethod，于是我們的就有了下面的推導(dǎo)：

最終我們的表達(dá)式就變成了這樣：

List<String> str = Arrays.asList("a","b","A","B");
        str.sort(String::compareToIgnoreCase);

2. 方法引用對(duì)于對(duì)象構(gòu)造的抽象

實(shí)際上對(duì)象構(gòu)造也可以通過(guò)方法引用表達(dá)，其整體縮寫(xiě)的語(yǔ)法和靜態(tài)方法引用類似，如下圖所示本質(zhì)上new的動(dòng)作就可以直接理解為對(duì)于new的調(diào)用，同理簡(jiǎn)寫(xiě)為className::new來(lái)表達(dá)：

我們不妨結(jié)合幾個(gè)例子進(jìn)行說(shuō)明，如下便是蘋(píng)果對(duì)象的類定義，即帶有重量、顏色等屬性，同時(shí)支持含參或不含參的方式構(gòu)造：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Apple {
    private int weight;

    private String color;


}

簡(jiǎn)單的蘋(píng)果對(duì)象創(chuàng)建就像下面這樣new創(chuàng)建

//普通對(duì)象創(chuàng)建
        Apple apple = new Apple();

實(shí)際上這個(gè)創(chuàng)建步驟在函數(shù)式中可以抽象的理解為Supplier接口()->T，其中T為Apple，所以我們表達(dá)式可以轉(zhuǎn)換為如下方式：

Supplier<Apple> apply = () -> new Apple();
 Apple apple1 = apply.get();

此時(shí)，基于我們上述的圖解，即可將Supplier對(duì)象構(gòu)造推導(dǎo)出構(gòu)造函數(shù)的方法引用：

于是就有了下方代碼：

//采用方法引用縮寫(xiě)
        Supplier<Apple> apply2 = Apple::new;
        Apple apple2 = apply2.get();

我們?cè)賮?lái)一個(gè)難一點(diǎn)的例子，因?yàn)槲覀兊臉?gòu)造器為傳參順序?yàn)閣eight、color然后創(chuàng)建Apple實(shí)例，對(duì)此我們可以大體抽象出函數(shù)式接口的簽名為(Integer,String)->Apple，基于這個(gè)簽名我們可以直接套用公式BiFunction，它的簽名為(T,U)->R，參數(shù)列表符合要求，我們直接將類型代入完成函數(shù)式接口抽象：

private static Apple createApple(Integer weight,String color,BiFunction<Integer, String, Apple> func) {
        return func.apply(weight, color);
    }

基于上述的簽名的參數(shù)列表和預(yù)期返回值，我們得出下面這樣一條lambda表達(dá)式作為入?yún)魅?，由此得到一個(gè)Apple實(shí)例：

createApple(1,"yellow",(w,s)->new Apple(w,s));

按照上文所說(shuō)的公式，于是我們的表達(dá)式又可以轉(zhuǎn)為方法引用：

對(duì)應(yīng)的代碼如下所示：

createApple(1,"yellow",Apple::new);

3. lambda和方法引用的結(jié)合

我們希望對(duì)蘋(píng)果類進(jìn)行排序，對(duì)此我們給出蘋(píng)果類的實(shí)例集合：

List<Apple> appleList = Arrays.asList(new Apple(80, "green"),
                new Apple(200, "red"),
                new Apple(155, "yellow"),
                new Apple(120, "red"));

查看函數(shù)式接口Comparator的抽象方法 int compare(T o1, T o2);得出對(duì)應(yīng)的函數(shù)簽名為(T,T)->Integer，代入我們的Apple類，那么這個(gè)比較器的函數(shù)描述符則是(Apple,Apple)->Integer，于是我們就有了下面這條lambda表達(dá)式：

Comparator<Apple> comparator = (a1,a2)->a1.getWeight()-a2.getWeight();

我們鍵入如下代碼進(jìn)行調(diào)用輸出：

appleList.sort(comparator);
 appleList.forEach(System.out::println);

和預(yù)期比較結(jié)果一致：

Apple(weight=80, color=green)
Apple(weight=120, color=red)
Apple(weight=155, color=yellow)
Apple(weight=200, color=red)

實(shí)際上我們還可以做的更加精簡(jiǎn)，因?yàn)镴DK8中的Comparator已經(jīng)為比較器提供了一個(gè)方法comparing，查看其源碼可以看到他要求傳入一個(gè)入?yún)eyExtractor，從語(yǔ)義上就可以知道這個(gè)參數(shù)是作為比較的條件，以我們的例子就是Apple的weight。 這個(gè)keyExtractor是Function接口，查看其泛型我們也可以知曉它的函數(shù)式簽名為T(mén)->R，由此我們可以推理出該方法本質(zhì)就是通過(guò)Function接口變量keyExtractor生成比較變量的實(shí)例然后調(diào)用compareTo進(jìn)行比較并返回結(jié)果：

//要求傳入keyExtractor即作為比較的條件
public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        //......
        return (Comparator<T> & Serializable)
         //通過(guò)keyExtractor生成key值調(diào)用其compareTo方法進(jìn)行比較
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }

基于上述分析我們就可以開(kāi)始編寫(xiě)這個(gè)比較器的keyExtractor的lambda表達(dá)式了，如下圖，通過(guò)keyExtractor泛型得出函數(shù)描述符為(T)->R，基于我們的場(chǎng)景推導(dǎo)出公式是apple實(shí)例->apple實(shí)例的weight，最后comparing會(huì)基于這個(gè)函數(shù)接口生成的R對(duì)象(我們的場(chǎng)景是weight即int類型)調(diào)用compareTo進(jìn)行比較：

于是我們就有了這樣一條lambda表達(dá)式，但這還不是最精簡(jiǎn)的：

Comparator<Apple> comparator = Comparator.comparing(a->a.getWeight());

按照l(shuí)ambda的語(yǔ)法糖:instance->instance.method 可以直接轉(zhuǎn)為instanceType::method，我們最終的表達(dá)式如下，預(yù)期結(jié)果也和之前一致：

Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight);

當(dāng)然有時(shí)候我們希望能夠?qū)Y(jié)果進(jìn)行反向排序，我們也只需在comparing方法后面加一個(gè)reversed即實(shí)現(xiàn)，從語(yǔ)義和使用上是不是都很方便呢？

Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight).reversed();

二、復(fù)合表達(dá)式

1. 復(fù)合比較器

自此我們基本將方法引用的推導(dǎo)和使用都講完了，接下來(lái)我們還是基于lambda做一些實(shí)用的拓展，先來(lái)說(shuō)說(shuō)復(fù)合比較器，以上文的蘋(píng)果為例，假設(shè)我們希望當(dāng)重量一樣時(shí)，在比較顏色進(jìn)行進(jìn)一步比較，那么我們就可以直接通過(guò)thenComparing生成復(fù)合表達(dá)式：

Comparator<Apple> comparator = Comparator.comparing(Apple::getWeight).reversed().thenComparing(Apple::getColor);

2. 謂詞復(fù)合

還是用上面的例子，我們希望根據(jù)不同的條件從蘋(píng)果集合中過(guò)濾出復(fù)合條件的蘋(píng)果，對(duì)此我們基于Predicate即斷言函數(shù)式接口編寫(xiě)了一個(gè)filterApple方法：

private static List<Apple> filterApple(List<Apple> appleList, Predicate<Apple> predicate) {
        List<Apple> list = new ArrayList<>();
        for (Apple apple : appleList) {
            //復(fù)合predicate設(shè)定條件的蘋(píng)果存入集合中
            if (predicate.test(apple)) {
                list.add(apple);
            }
        }
        return list;
    }

假如客戶需要過(guò)濾出紅色的蘋(píng)果，基于predicate的簽名我們得出這樣一個(gè)表達(dá)式，這里就不多介紹了：

filterApple(appleList, apple -> apple.getColor().equals("red"));

假如這時(shí)候我們有需要過(guò)濾出不為紅色的蘋(píng)果呢？其實(shí)JDK8為我們提供了一個(gè)非常強(qiáng)大的謂詞negate，我們完全可以基于上面的代碼進(jìn)行改造從而實(shí)現(xiàn)需求，如下所示negate就相當(dāng)于!"red".equals(a.getColor());，語(yǔ)義是不是很清晰呢？

Predicate<Apple> predicate = apple -> apple.getColor().equals("red");
        filterApple(appleList, predicate.negate());

但是我們需要再次變化了，我們希望找出紅色且重量大于150，或者顏色為綠色的蘋(píng)果，這時(shí)候又怎么辦呢？我們說(shuō)過(guò)JDK8提供了and、or等謂詞，我們的代碼完全可以寫(xiě)成下文所示,可以看到代碼語(yǔ)義以及流暢度都相比JDK8之前的各種&& ||拼接for循環(huán)來(lái)說(shuō)優(yōu)雅非常多：

//過(guò)濾出紅色的蘋(píng)果
        Predicate<Apple> predicate = apple -> apple.getColor().equals("red");
        //過(guò)濾出紅色且大于150 或者綠色的蘋(píng)果
        Predicate<Apple> redAndHeavyAppleOrGreen = predicate.and(apple -> apple.getWeight() > 150).
                or(apple -> apple.getColor().equals("green"));


        filterApple(appleList, redAndHeavyAppleOrGreen);

3. 函數(shù)復(fù)合

我們都說(shuō)代碼和數(shù)學(xué)息息相關(guān)，其實(shí)java8也提供很多函數(shù)式接口可以運(yùn)用于數(shù)學(xué)公式上,例如，我們現(xiàn)在需要計(jì)算f(g(x))，這個(gè)公式學(xué)過(guò)高數(shù)的同學(xué)都知道，是先計(jì)算g(x)再將g(x)的結(jié)果作為入?yún)⒔唤of(x)計(jì)算，對(duì)應(yīng)題解案例如下：

我們假設(shè)g(x)=x * 2
f(x)=x+1
假如x=1
那么g(f(x))最終就會(huì)等于4

了解數(shù)學(xué)公式之后，我們完全可以使用java代碼表示出來(lái)，首先我們先聲明一下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))，通過(guò)復(fù)合表達(dá)式andThen表達(dá)了數(shù)學(xué)的計(jì)算順序，即顯得出f(x)結(jié)果，然后(andThen)代入g(x)中：

//意味先計(jì)算f(x)在計(jì)算g(x)
 Function<Integer, Integer> h = f.andThen(g);
System.out.println(result); //輸出 4

基于上面的例子，如果我們還需要計(jì)算f(g(x))要怎么辦呢？從f(x)角度來(lái)看，g(x)的結(jié)果組合到f(x)上，所以我們可以直接實(shí)用compose方法：

Function<Integer, Integer> fgx = f.compose(g);
Integer result = fgx.apply(1);
System.out.println(result);// 輸出 3

其實(shí),按照奧卡姆剃刀守則，如果按照筆者的習(xí)慣，會(huì)優(yōu)先使用第一種，即fg(x)用 g.andThen(f);,即先算g再算f,而gf(x)則用f.andThen(g);即先算f再算g。