摘要：通常，這種模式是通過定義一個代表處理對象的抽象類來實現的，在抽象類中會定義一個字段來記錄后續對象。工廠模式使用表達式第章中，我們已經知道可以像引用方法一樣引用構造函數。
一、為改善可讀性和靈活性重構代碼
1.改善代碼的可讀性
Java 8的新特性也可以幫助提升代碼的可讀性：
使用Java 8，你可以減少冗長的代碼，讓代碼更易于理解
通過方法引用和Stream API，你的代碼會變得更直觀
這里我們會介紹三種簡單的重構，利用Lambda表達式、方法引用以及Stream改善程序代碼的可讀性：
重構代碼，用Lambda表達式取代匿名類
用方法引用重構Lambda表達式
用Stream API重構命令式的數據處理
2.從匿名類到 Lambda 表達式的轉換
在匿名類中，this代表的是類自身，但是在Lambda中，它代表的是包含類。其次，匿名類可以屏蔽包含類的變量，而Lambda表達式不
能（它們會導致編譯錯誤），譬如下面這段代碼：
int a = 10;
Runnable r1 = () -> {
int a = 2; //類中已包含變量a
System.out.println(a);
};
對于參數相同的函數式接口，調用時會造成都符合Lambda表達式的結果，不過NetBeans和IntelliJ都支持這種重構，它們能自動地幫你檢查，避免發生這些問題。
3.從Lambda 表達式到方法引用的轉換
按照食物的熱量級別對菜肴進行分類：
Map> dishesByCaloricLevel =
menu.stream()
.collect(
groupingBy(dish -> {
if (dish.getCalories() <= 400) return CaloricLevel.DIET;
else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL;
else return CaloricLevel.FAT;
}));
你可以將Lambda表達式的內容抽取到一個多帶帶的方法中，將其作為參數傳遞給groupingBy
方法。變換之后，代碼變得更加簡潔，程序的意圖也更加清晰了：
Map> dishesByCaloricLevel =
menu.stream().collect(groupingBy(Dish::getCaloricLevel));
為了實現這個方案，你還需要在Dish類中添加getCaloricLevel方法：
public class Dish{
…
public CaloricLevel getCaloricLevel(){
if (this.getCalories() <= 400) return CaloricLevel.DIET;
else if (this.getCalories() <= 700) return CaloricLevel.NORMAL;
else return CaloricLevel.FAT;
}
}
除此之外，我們還應該盡量考慮使用靜態輔助方法，比如comparing、maxBy。
inventory.sort(
(Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight()));
inventory.sort(comparing(Apple::getWeight));
使用Collectors接口可以輕松得到和或者最大值，與采用Lambada表達式和底層的歸約操作比起來，這種方式要直觀得多.
int totalCalories =
menu.stream().map(Dish::getCalories)
.reduce(0, (c1, c2) -> c1 + c2);
int totalCalories = menu.stream().collect(summingInt(Dish::getCalories));
4.從命令式的數據處理切換到 Stream
原來：
List dishNames = new ArrayList<>();
for(Dish dish: menu){
if(dish.getCalories() > 300){
dishNames.add(dish.getName());
}
}
替換成流式：
menu.parallelStream()
.filter(d -> d.getCalories() > 300)
.map(Dish::getName)
.collect(toList());
5.增加代碼的靈活性
(1)采用函數接口
用Lambda表達式帶來的靈活性，它們分別是：有條件的延遲執行和環繞執行。
(2)有條件的延遲執行
如果你發現你需要頻繁地從客戶端代碼去查詢一個對象的狀態，只是為了傳遞參數、調用該對象的一個方法（比如輸出一條日志），那么可以考慮實現一個新的方法，以Lambda或者方法表達式作為參數，新方法在檢查完該對象的狀態之后才調用原來的方法。
(3)環繞執行
如果你發現雖然你的業務代碼千差萬別，但是它們擁有同樣的準備和清理階段，這時，你完全可以將這部分代碼用Lambda實現。這種方式的好處是可以重用準備和清理階段的邏輯，減少重復冗余的代碼。
String oneLine =
processFile((BufferedReader b) -> b.readLine());
String twoLines =
processFile((BufferedReader b) -> b.readLine() + b.readLine());
public static String processFile(BufferedReaderProcessor p) throws
IOException {
try(BufferedReader br = new BufferedReader(new FileReader("java8inaction/
chap8/data.txt"))){
return p.process(br);
}
}
public interface BufferedReaderProcessor{
String process(BufferedReader b) throws IOException;
}
二、使用 Lambda 重構面向對象的設計模式
1.策略模式
策略模式代表了解決一類算法的通用解決方案，你可以在運行時選擇使用哪種方案。
數字）。你可以從定義一個驗證文本（以String的形式表示）的接口入手：
public interface ValidationStrategy {
boolean execute(String s);
}
其次，你定義了該接口的一個或多個具體實現：
public class IsAllLowerCase implements ValidationStrategy {
public boolean execute(String s){
return s.matches("[a-z]+");
}
}
public class IsNumeric implements ValidationStrategy {
public boolean execute(String s){
return s.matches("d+");
}
}
之后，你就可以在你的程序中使用這些略有差異的驗證策略了：
public class Validator{
private final ValidationStrategy strategy;
public Validator(ValidationStrategy v){
this.strategy = v;
}
public boolean validate(String s){
return strategy.execute(s);
}
}
Validator numericValidator = new Validator(new IsNumeric());
boolean b1 = numericValidator.validate("aaaa");
Validator lowerCaseValidator = new Validator(new IsAllLowerCase ());
boolean b2 = lowerCaseValidator.validate("bbbb");
如果使用Lambda表達式，則為：
Validator numericValidator =
new Validator((String s) -> s.matches("[a-z]+"));
boolean b1 = numericValidator.validate("aaaa");
Validator lowerCaseValidator =
new Validator((String s) -> s.matches("d+"));
boolean b2 = lowerCaseValidator.validate("bbbb");
2.模板方法
如果你需要采用某個算法的框架，同時又希望有一定的靈活度，能對它的某些部分進行改進，那么采用模板方法設計模式是比較通用的方案。
abstract class OnlineBanking {
public void processCustomer(int id){
Customer c = Database.getCustomerWithId(id);
makeCustomerHappy(c);
}
abstract void makeCustomerHappy(Customer c);
}
processCustomer方法搭建了在線銀行算法的框架：獲取客戶提供的ID，然后提供服務讓用戶滿意。不同的支行可以通過繼承OnlineBanking類，對該方法提供差異化的實現。
如果使用Lambda表達式：
public void processCustomer(int id, Consumer makeCustomerHappy){
Customer c = Database.getCustomerWithId(id);
makeCustomerHappy.accept(c);
}
new OnlineBankingLambda().processCustomer(1337, (Customer c) ->
System.out.println("Hello " + c.getName());
3.觀察者模式
例子：好幾家報紙機構，比如《紐約時報》《衛報》以及《世界報》都訂閱了新聞，他們希望當接收的新聞中包含他們感興趣的關鍵字時，能得到特別通知。
interface Observer {
void notify(String tweet);
}
class NYTimes implements Observer{
public void notify(String tweet) {
if(tweet != null && tweet.contains("money")){
System.out.println("Breaking news in NY! " + tweet);
}
}
}
class Guardian implements Observer{
public void notify(String tweet) {
if(tweet != null && tweet.contains("queen")){
System.out.println("Yet another news in London... " + tweet);
}
}
}
class LeMonde implements Observer{
public void notify(String tweet) {
if(tweet != null && tweet.contains("wine")){
System.out.println("Today cheese, wine and news! " + tweet);
}
}
}
interface Subject{
void registerObserver(Observer o);
void notifyObservers(String tweet);
}
class Feed implements Subject{
private final List observers = new ArrayList<>();
public void registerObserver(Observer o) {
this.observers.add(o);
}
public void notifyObservers(String tweet) {
observers.forEach(o -> o.notify(tweet));
}
}
Feed f = new Feed();
f.registerObserver(new NYTimes());
f.registerObserver(new Guardian());
f.registerObserver(new LeMonde());
f.notifyObservers("The queen said her favourite book is Java 8 in Action!");
使用Lambda表達式后，你無需顯式地實例化三個觀察者對象，直接傳遞Lambda表達式表示需要執行的行為即可：
f.registerObserver((String tweet) -> {
if(tweet != null && tweet.contains("money")){
System.out.println("Breaking news in NY! " + tweet);
}
});
f.registerObserver((String tweet) -> {
if(tweet != null && tweet.contains("queen")){
System.out.println("Yet another news in London... " + tweet);
}
});
4.責任鏈模式
責任鏈模式是一種創建處理對象序列（比如操作序列）的通用方案。一個處理對象可能需要在完成一些工作之后，將結果傳遞給另一個對象，這個對象接著做一些工作，再轉交給下一個處理對象，以此類推。通常，這種模式是通過定義一個代表處理對象的抽象類來實現的，在抽象類中會定義一個字段來記錄后續對象。一旦對象完成它的工作，處理對象就會將它的工作轉交給它的后繼。
public abstract class ProcessingObject {
protected ProcessingObject successor;
public void setSuccessor(ProcessingObject successor){
this.successor = successor;
}
public T handle(T input){
T r = handleWork(input);
if(successor != null){
return successor.handle(r);
}
return r;
}
abstract protected T handleWork(T input);
}
public class HeaderTextProcessing extends ProcessingObject {
public String handleWork(String text){
return "From Raoul, Mario and Alan: " + text;
}
}
public class SpellCheckerProcessing extends ProcessingObject {
public String handleWork(String text){
return text.replaceAll("labda", "lambda");
}
}
ProcessingObject p1 = new HeaderTextProcessing();
ProcessingObject p2 = new SpellCheckerProcessing();
p1.setSuccessor(p2);//將兩個處理對象鏈接起來
String result = p1.handle("Aren"t labdas really sexy?!!");
System.out.println(result);
使用Lambda表達式
你可以將處理對象作為函數的一個實例，或者更確切地說作為UnaryOperator的一個實例。為了鏈接這些函數，你需要使用andThen方法對其進行構造。
UnaryOperator headerProcessing =
(String text) -> "From Raoul, Mario and Alan: " + text;
UnaryOperator spellCheckerProcessing =
(String text) -> text.replaceAll("labda", "lambda");
Function pipeline =
headerProcessing.andThen(spellCheckerProcessing);
String result = pipeline.apply("Aren"t labdas really sexy?!!");
5.工廠模式
public class ProductFactory {
public static Product createProduct(String name){
switch(name){
case "loan": return new Loan();
case "stock": return new Stock();
case "bond": return new Bond();
default: throw new RuntimeException("No such product " + name);
}
}
}
Product p = ProductFactory.createProduct("loan");
使用Lambda表達式
第3章中，我們已經知道可以像引用方法一樣引用構造函數。比如，下面就是一個引用貸款
（Loan）構造函數的示例：
構造器參數列表要與接口中抽象方法的參數列表一致!因此，如果構造方法中有多個參數，需要自定義函數式接口。
Supplier loanSupplier = Loan::new;
Loan loan = loanSupplier.get();
通過這種方式，你可以重構之前的代碼，創建一個Map，將產品名映射到對應的構造函數：
final static Map> map = new HashMap<>();
static {
map.put("loan", Loan::new);
map.put("stock", Stock::new);
map.put("bond", Bond::new);
}
現在，你可以像之前使用工廠設計模式那樣，利用這個Map來實例化不同的產品。
public static Product createProduct(String name){
Supplier p = map.get(name);
if(p != null) return p.get();
throw new IllegalArgumentException("No such product " + name);
}
三、測試 Lambda 表達式
你可以借助某個字段訪問Lambda函數
要對使用Lambda表達式的方法進行測試
一種策略是將Lambda表達式轉換為方法引用，然后按照常規方式
接受函數作為參數的方法或者返回一個函數的方法（所謂的“高階函數”，higher-order function，我們在第14章會深入展開介紹）更難測試。如果一個方法接受Lambda表達式作為參數，你可以采用的一個方案是使用不同的Lambda表達式對它進行測試。
文中提到了List的equals方法
ArrayList、Vector兩者都實現了List接口、繼承AbstractList抽象類，其equals方法是在AbstractList類中定義的，源代碼如下：
public boolean equals(Object o) {
if (o == this)
return true;
// 判斷是否是List列表，只要實現了List接口就是List列表
if (!(o instanceof List))
return false;
// 遍歷list所有元素
ListIterator e1 = listIterator();
ListIterator e2 = ((List) o).listIterator();
while (e1.hasNext() && e2.hasNext()) {
E o1 = e1.next();
Object o2 = e2.next();
// 有不相等的就退出
if (!(o1==null ? o2==null : o1.equals(o2)))
return false;
}
// 長度是否相等
return !(e1.hasNext() || e2.hasNext());
從源碼可以看出，equals方法并不關心List的具體實現類，只要是實現了List接口，并且所有元素相等、長度也相等的話就表明兩個List是相等的，所以例子中才會返回true。
四、調試
1.查看棧跟蹤
由于Lambda表達式沒有名字，它的棧跟蹤可能很難分析,編譯器只能為它們指定一個名字,如果你使用了大量的類，其中又包含多個Lambda表達式，這就成了一個非常頭痛的問題,這是Java編譯器未來版本可以改進的一個方面。
2.使用日志調試
這就是流操作方法peek大顯身手的時候。peek的設計初衷就是在流的每個元素恢復運行之前，插入執行一個動作。但是它不像forEach那樣恢復整個流的運行，而是在一個元素上完成操作之后，它只會將操作順承到流水線中的下一個操作。
List numbers = Arrays.asList(2, 3, 4, 5);
List result =
numbers.stream()
.peek(x -> System.out.println("from stream: " + x))
//輸出來自數據源的當前元素值
.map(x -> x + 17)
.peek(x -> System.out.println("after map: " + x))
//輸 出 map操作的結果
.filter(x -> x % 2 == 0)
.peek(x -> System.out.println("after filter: " + x))
//輸出經過filter操作之后，剩下的元素個數
.limit(3)
.peek(x -> System.out.println("after limit: " + x))
//輸出經過limit操作之后，剩下的元素個數
.collect(toList());
輸出結果：
from stream: 2
after map: 19
from stream: 3
after map: 20
after filter: 20
after limit: 20
from stream: 4
after map: 21
from stream: 5
after map: 22
after filter: 22
after limit: 22
