[[396939]]

本文轉載自微信公眾號「今日Java」，作者麥洛。轉載本文請聯系今日Java公眾號。  

• 前言
• 第一次 按類型篩選瓜類
• 第二次 按重量篩選瓜類
• 第三次 按類型和重量篩選瓜類
• 第四次 將行為作為參數傳遞
• 第五次 一次性加了100個過濾條件
• 第六次 引入泛型
• 簡而言之Lambda
• 總結

前言

Hi,大家好,我是麥洛。我又回來啦??

進來給大家八卦一段,看看我自己都去干啥了?話說最近公司接了一個農產品交易網站新項目，因為一段代碼重構問題差點和老大干起來，本來以為是老大故意刁難我。最后還是發現是我太菜了?事情是這個樣子滴!

在周例會上，老大告知我們最近接了一個農產品交易平臺，主要用于全省農產品線上交易。首當其中，就是要把我們甘肅省的黃河蜜推銷出去，我就被安排賣瓜!嗷，不，賣瓜這個功能我負責開發?;很快我設計下面的類來定義瓜 Melon 類：

/** 
 * 瓜 
 * @author Milo Lee 
 * @date 2021-04-07 13:21 
 */ 
public class Melon { 
    /**品種*/ 
    private final String type; 
    /**重量*/ 
    private final int weight; 
    /**產地*/ 
    private final String origin; 
 
    public Melon(String type, int weight, String origin) { 
        this.type = type; 
        this.weight = weight; 
        this.origin = origin; 
    } 
    // getters, toString()方法省略 
} 

經過一頓CRUD騷操作，寫完了瓜類增刪改查工作，交工下班。

第一次 按類型篩選瓜類

第二天，老大給我提了一個問題，說增加能夠按瓜類型對瓜進行過濾。這不很簡單嗎?于是，于是我創建了一個 Filters 類， 實現了一個filterMelonByType方法

/** 
 * @author Milo Lee 
 * @date 2021-04-07 13:25 
 */ 
public class Filters { 
 
    /** 
     * 根據類型篩選瓜類 
     * @param melons 瓜類 
     * @param type 類型 
     * @return 
     */ 
    public static List<Melon> filterMelonByType(List<Melon> melons, String type) { 
 
        List<Melon> result = new ArrayList<>(); 
        for (Melon melon: melons) { 
            if (melon != null && type.equalsIgnoreCase(melon.getType())) { 
                result.add(melon); 
            } 
        } 
        return result; 
    } 
} 

搞定，我們來測試一下：

public static void main(String[] args) { 
    ArrayList<Melon> melons = new ArrayList<>(); 
    melons.add(new Melon("羊角蜜", 1, "泰國")); 
    melons.add(new Melon("西瓜", 2, "三亞")); 
    melons.add(new Melon("黃河蜜", 3, "蘭州")); 
    List<Melon> melonType = Filters.filterMelonByType(melons, "黃河蜜"); 
    melonType.forEach(melon->{ 
    System.out.println("瓜類型:"+melon.getType()); 
    }); 
} 

沒毛病，拿給老大看看去，老大看了我的代碼說：如果我讓你在增加一個按重量篩選瓜類,你打算怎么寫?回去考慮一下吧,這家伙不會故意找我茬吧???

第二次 按重量篩選瓜類

回到座位的我心想,上次我已經實現了按類型篩選瓜類，那我給他copy一份改改吧!

如下所示：

/** 
 * 按照重量過濾瓜類 
 * @param melons 
 * @param weight 
 * @return 
 */ 
public static List<Melon> filterMelonByWeight(List<Melon> melons, int weight) { 
 
    List<Melon> result = new ArrayList<>(); 
    for (Melon melon: melons) { 
        if (melon != null && melon.getWeight() == weight) { 
            result.add(melon); 
        } 
    } 
    return result; 
} 

public static void main(String[] args) { 
      ArrayList<Melon> melons = new ArrayList<>(); 
        melons.add(new Melon("羊角蜜", 1, "泰國")); 
        melons.add(new Melon("西瓜", 2, "三亞")); 
        melons.add(new Melon("黃河蜜", 3, "蘭州")); 
        List<Melon> melonType = Filters.filterMelonByType(melons, "黃河蜜"); 
        melonType.forEach(melon->{ 
            System.out.println("瓜類型:"+melon.getType()); 
        }); 
 
        List<Melon> melonWeight = Filters.filterMelonByWeight( melons,3); 
        melonWeight.forEach(melon->{ 
            System.out.println("瓜重量:"+melon.getWeight()); 
        }); 
    } 

程序員最喜歡的方式,CV搞定,哈哈。但是我發現filterByWeight()與 filterByType() 非常相似，就是過濾條件不同。我心想，老大不會讓我寫一個按類型和重量篩選瓜類吧。拿著我的代碼去給老大看，果不其然，怕什么來什么。

第三次 按類型和重量篩選瓜類

為了滿足完成老大的任務，我將上面的代碼進行了糅合，很快寫了如下的代碼：

/** 
 * 按照類型和重量來篩選瓜類 
 * @param melons 
 * @param type 
 * @param weight 
 * @return 
 */ 
public static List<Melon> filterMelonByTypeAndWeight(List<Melon> melons, String type, int weight) { 
 
    List<Melon> result = new ArrayList<>(); 
    for (Melon melon: melons) { 
        if (melon != null && type.equalsIgnoreCase(melon.getType()) && melon.getWeight() == weight) { 
            result.add(melon); 
        } 
    } 
    return result; 
} 

老大看了我的代碼說，看來你還是沒有理解我的意思。假如今天不光我，還有客戶繼續這樣提需求。

那么 Filters 將會有很多這樣類似的方法，也就是說寫了很多樣板代碼(代碼冗余但又不得不寫);

在我們程序員看來，這是不能接受的。如果繼續添加新的過濾條件，則代碼將變得難以維護且容易出錯。你去了解一下lambda表達式和函數式接口知識點,再修改一下你的代碼。我已經確定了，他就是和我過不去？

第四次 將行為作為參數傳遞

經過上面的三番折騰。我發現理論上Melon類的任何屬性都有可能作為過濾條件，這樣的話我們的Filter類將會有大量的樣板代碼，而且有些方法會非常復雜。

其實我們可以發現，我們每寫一個方法，都對應一種查詢行為，查詢行為必然對應一種過濾條件。有沒有辦法我們寫一個方法，將查詢行為作為參數傳遞進去，從而返回我們的結果呢?

那么給它取了一個名字：行為參數化，在下圖中進行了說明(左側顯示了我們現在擁有的；右側顯示了我們想要的)，有沒有發現樣板代碼會明顯減少??

如果我們將過濾條件視為一種行為，那么將每種行為視為接口的實現是非常直觀的。經過分析我們發現以上所有這些行為都有一個共同點：過濾條件和boolean 類型的返回 。抽象一個接口如下：

public interface MelonPredicate { 
  boolean test(Melon melon); 
} 

例如，過濾 黃河蜜可以這樣寫： HHMMelonPredicate。

public class HHMMelonPredicate implements MelonPredicate { 
 
     @Override 
     public boolean test(Melon melon) { 
       return "黃河蜜".equalsIgnoreCase(melon.getType()); 
 
     } 
 
} 

以此類推，我們也可以過濾一定重量的瓜：

public class WeightMelonPredicate implements MelonPredicate { 
 
     @Override 
     public boolean test(Melon melon) { 
       return melon.getWeight() > 5000; 
     } 
 
} 

其實熟悉設計模式的同學應該知道這就是：策略設計模式。

主要思想就是讓系統在運行時動態選擇需要調用的方法。所以我們可以認為 MelonPredicate 接口統一了所有專用于篩選瓜類的算法，并且每種實現都是一種策略，我們也可以把它理解為一種行為。

目前，我們利用策略設計模式,將查詢行為進行了抽象。我們還需要一個方法接收 MelonPredicate 參數。于是我定義了 filterMelons() 方法，如下所示：

public static List<Melon> filterMelons(List<Melon> melons, MelonPredicate predicate) { 
     
    List<Melon> result = new ArrayList<>(); 
    for (Melon melon: melons) { 
      if (melon != null && predicate.test(melon)) { 
        result.add(melon); 
      } 
 
    }   
    return result; 
} 

大功告成，測試一下，果然比之前好用多了，再讓老大瞅瞅去

List<Melon> hhm = Filters.filterMelons(melons, new HHMMelonPredicate()); 
 
List<Melon> weight = Filters.filterMelons(melons, new WeightMelonPredicate()); 

第五次 一次性加了100個過濾條件

就在我沾沾自喜時候，老大又給他潑了一盆冷水。他說你以為我們的平臺就買黃河蜜啊，如果前前后后有幾十種瓜品種,我給你列出100種過濾條件,你怎么辦?

我的心里一萬個草泥馬在奔騰啊??!老大是不是存心和我過不去啊!雖然經過上次改造，我的代碼已經足夠靈活，但是如果突然增加100個過濾條件,我仍然需要編寫100個策略類來實現每一個過濾條件。然后我們需要將策略傳遞給 filterMelons() 方法。

有沒有不需要創建這些類的辦法那?聰明的我很快發現可以使用java匿名內部類。

如下所示：

List<Melon> europeans = Filters.filterMelons(melons, new MelonPredicate() { 
 
     @Override 
 
     public boolean test(Melon melon) { 
 
       return "europe".equalsIgnoreCase(melon.getOrigin()); 
 
     } 
 
}); 

雖然向前跨了一大步，但好像無濟于事。我還是需要編寫大量的代碼實現此次需求。設計匿名內部類的目的，就是為了方便 Java 程序員將代碼作為數據傳遞。有時候，匿名內部類看這比較復雜，這時候，我突然想起來老大讓我學的lambda表達式，我可以用它來簡化：

List<Melon> europeansLambda = Filters.filterMelons( 
  melons, m -> "europe".equalsIgnoreCase(m.getOrigin()) 
); 

果然看這帥多了!!!,就這樣,我又一次成功完成了任務。我興沖沖的拿著代碼讓老大去看看。

第六次 引入泛型

老大看著我的代碼說，嗯，不錯!腦袋終于開竅了。現在你考慮一下，我們的平臺是做農產品的，也就是肯定不止瓜這一類水果，如果換做其他的水果，你的代碼如何修改?

目前我們的MelonPredicate僅支持 Melon 類。這家伙怎么搞?說不定哪天他要買蔬菜、海參可怎么搞，總不能給他再創建好多類似MelonPredicate的接口吧。這個時候突然想起老師講過的泛型，該它發揮作用了!

于是我定義了一個新接口Predicate：

@FunctionalInterface 
public interface Predicate<T> { 
 
  boolean test(T t); 
 
} 

接下來，我們重寫該 filterMelons() 方法并將其重命名為 filter() ：

public static <T> List<T> filter(List<T> list, Predicate<T> predicate) { 
   
 List<T> result = new ArrayList<>(); 
 
    for (T t: list) { 
 
      if (t != null && predicate.test(t)) { 
 
        result.add(t); 
 
      } 
 
    }   
 
    return result; 
 
} 

現在，我們可以這樣過濾瓜類 ：

List<Melon> watermelons = Filters.filter( 
 
  melons, (Melon m) -> "Watermelon".equalsIgnoreCase(m.getType())); 

同樣的，我們也可以對數字做同樣的事情：

List<Integer> numbers = Arrays.asList(1, 13, 15, 2, 67); 
 
List<Integer> smallThan10 = Filters.filter(numbers, (Integer i) -> i < 10); 

回過頭來復盤一下，我們發現自從使用Java 8函數式接口和lambda表達式后，代碼發生了明顯的變化。

不知道細心的伙伴有沒有發現我們上面的 Predicate 接口上面多了一個@FunctionalInterface 上的注解，它就是標記函數式接口的。

至此，我們通過一個需求的演變過程，了解了lambda和函數式接口的概念，同時也加深對它們的理解。其實熟悉java8的朋友都知道，在我們的 java.util.function 包下包含40多個此類接口。

函數式接口和lambda表達式組成了一個強大的團隊。根據上面的例子，我們知道函數式接口是我們行為的高度抽象，lambda表達式我們可以看出這種行為的具體實現的一個實例。

Predicate<Melon> predicate = (Melon m)-> "Watermelon".equalsIgnoreCase(m.getType()); 

簡而言之Lambda

lambda表達式由三部分組成，如下圖所示：

以下是lambda表達式各部分的描述：

• 在箭頭的左側，是在lambda表達式主體中使用的參數。
• 在箭頭的右側，是lambda主體 。
• 箭頭只是lambda參數和主體的分隔符。

此lambda的匿名類版本如下：

List<Melon> europeans = Filters.filterMelons(melons, new Predicate<Melon>() { 
 
 @Override 
 
 public boolean test(Melon melon) { 
 
   return "Watermelon".equalsIgnoreCase(melon.getType()); 
 
 } 
 
}); 

現在，如果我們查看lambda表達式及其匿名類版本，可以從下面四方面來描述lambda表達式：

我們可以將 lambda 表達式定義為一種 簡潔、可傳遞的匿名函數，首先我們需要明確 lambda 表達式本質上是一個函數，雖然它不屬于某個特定的類，但具備參數列表、函數主體、返回類型，甚至能夠拋出異常;其次它是匿名的，lambda 表達式沒有具體的函數名稱;lambda 表達式可以像參數一樣進行傳遞，從而簡化代碼的編寫。

Lambda支持行為參數化，在前面的例子中,我們已經證明這一點。最后，請記住，lambda表達式只能在函數式接口的上下文中使用。

總結

在本文中，我們重點介紹了函數式接口的用途和可用性，我們將研究如何將代碼從開始的樣板代碼現演變為基于函數式接口的靈活實現。希望對大家理解函數式接口有所幫助，謝謝大家。