我們會介紹幾種方法，幫助你重構(gòu)代碼，以適配使用Lambda表達式，讓你的代碼具備更好的可讀性和靈活性。除此之外，我們還會討論目前比較流行的幾種面向?qū)ο蟮脑O(shè)計模式，
包括策略模式、模板方法模式、觀察者模式、責(zé)任鏈模式，以及工廠模式，在結(jié)合Lambda表達式之后變得更簡潔的情況。最后，我們會介紹如何測試和調(diào)試使用Lambda表達式和Stream API的代碼。

1. 為改善可讀性和靈活性重構(gòu)代碼

1.1 改善代碼的可讀性

Java 8的新特性也可以幫助提升代碼的可讀性:

• 使用Java 8，你可以減少冗長的代碼，讓代碼更易于理解
• 通過方法引用和Stream API，你的代碼會變得更直觀

利用Lambda表達式、方法引用以及Stream改善程序代碼的可讀性:

• 重構(gòu)代碼，用Lambda表達式取代匿名類
• 用方法引用重構(gòu)Lambda表達式
• 用Stream API重構(gòu)命令式的數(shù)據(jù)處理

1.2 從匿名內(nèi)部類到Lambda表達式的轉(zhuǎn)換

將實現(xiàn)單一抽象方法的匿名類轉(zhuǎn)換為Lambda表達式

// 傳統(tǒng)的方式，使用匿名類
Runnable r1 = new Runnable(){
    public void run(){
        System.out.println("Hello");
    }
}
// 新的方式，使用Lambda表達式
Runnable r2 = () -> System.out.println("Hello");

匿名 類和Lambda表達式中的this和super的含義是不同的。在匿名類中，this代表的是類自身，但是在Lambda中，它代表的是包含類。其次，匿名類可以屏蔽包含類的變量，而Lambda表達式不能(它們會導(dǎo)致編譯錯誤)，如下面這段代碼:

int a = 10;
Runnable r1 = () -> {
    int a = 2;                    // 編譯錯誤
    System.out.println(a);
};
Runnable r2 = new Runnable() {
    public void run() {
        int a = 2;                // 正常
        System.out.println(a);
    }
}

在涉及重??的上下文里，將匿名類轉(zhuǎn)換為Lambda表達式可能導(dǎo)致最終的代碼更加晦澀。實際上，匿名類的類型是在初始化時確定的，而Lambda的類型取決于它的上下文。通過下面這個例子，我們可以了解問題是如何發(fā)生的。我們假設(shè)你用與Runnable同樣的簽名聲明了一個函數(shù)接口，我們稱之為Task:

interface Task{
    public void execute();
}
public static void doSomething(Runnable r){ r.run(); }
public static void doSomething(Task a){ a.execute(); }
doSomething(new Task() {
        public void execute() {
            System.out.println("Danger danger!!");
        }
});
// doSomething(Runnable) 和 doSomething(Task) 都匹配該類型
doSomething(() -> System.out.println("Danger danger!!"));
// 使用顯式的類型轉(zhuǎn)換來解決這種模棱兩可的情況
doSomething((Task)() -> System.out.println("Danger danger!!"));

目前大多數(shù)的集成開發(fā)環(huán)境，比如NetBeans和IntelliJ都支持這種重構(gòu)，它們能自動地幫你檢查，避免發(fā)生這些問題。

1.3 從Lambda表達式到方法引用的轉(zhuǎn)換

Map<CaloricLevel, List<Dish>> 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表達式的內(nèi)容抽取到一個單獨的方法中，將其作為參數(shù)傳遞給groupingBy方法。變換之后，代碼變得更加簡潔，程序的意圖也更加清晰了。

Map<CaloricLevel, List<Dish>> dishesByCaloricLevel = menu.stream().collect(groupingBy(Dish::getCaloricLevel));

1.4 從命令式的數(shù)據(jù)處理切換到Stream

我們建議你將所有使用迭代器這種數(shù)據(jù)處理模式處理集合的代碼都轉(zhuǎn)換成Stream API的方式。為什么呢?
Stream API能更清晰地表達數(shù)據(jù)處理管道的意圖。除此之外，通過短路和延遲載入以及利用第7章介紹的現(xiàn)代計算機的多核架構(gòu)，我們可以對Stream進行優(yōu)化。

// 命令式版本
List<String> dishNames = new ArrayList<>();
    for(Dish dish: menu){
        if(dish.getCalories() > 300){
            dishNames.add(dish.getName());
    }
}
// 使用Stream API
menu.parallelStream()
        .filter(d -> d.getCalories() > 300)
        .map(Dish::getName)
        .collect(toList());

1.5 增加代碼的靈活性

沒有函數(shù)式接口就無法使用Lambda表達式，因此代碼中需要引入函數(shù)式接口。引入函數(shù)式接口的兩種通用模式：

• 有條件的延遲執(zhí)行
• 環(huán)繞執(zhí)行

2. 使用Lambda重構(gòu)面向?qū)ο蟮脑O(shè)計模式

使用Lambda表達式后，很多現(xiàn)存的略顯臃腫的面向?qū)ο笤O(shè)計模式能夠用更精簡的方式實現(xiàn)了。這一節(jié)中，我們會針對五個設(shè)計模式展開討論，它們分別是:

• 策略模式
• 模板方法
• 觀察者模式
• 責(zé)任鏈模式
• 工廠模式

2.1 策略模式

策略模式代表了解決一類算法的通用解決方案，你可以在運行時選擇使用哪種方案。策略模式包含三部分內(nèi)容，如圖所示。

• 一個代表某個算法的接口(它是策略模式的接口)。
• 一個或多個該接口的具體實現(xiàn)，它們代表了算法的多種實現(xiàn)(比如，實體類ConcreteStrategyA或者ConcreteStrategyB)。
• 一個或多個使用策略對象的客戶。

public interface ValidationStrategy {
        boolean execute(String s);
}
public class IsAllLowerCase implements ValidationStrategy {
    @Override
    public boolean execute(String s) {
        return s.matches("[a-z]+");
    }
}
public class IsNumber implements ValidationStrategy {
    @Override
    public boolean execute(String s) {
        return s.matches("\\d+");
    }
}
public class Validator {
    private final ValidationStrategy strategy;
    public Validator(ValidationStrategy strategy) {
        this.strategy = strategy;
    }
    public boolean validate(String s) {
        return strategy.execute(s);
    }
}
public class StrategyDemo {
    public static void main(String[] args) {
        Validator numericValidator = new Validator(new IsNumber());
        boolean b1 = numericValidator.validate("aaaa");
        Validator lowerCaseValidator = new Validator(new IsAllLowerCase());
        boolean b2 = lowerCaseValidator.validate("bbbb");
        System.out.println(b1 + " " + b2);
        Validator numericValidator1 = new Validator((String s) -> s.matches("[a-z]+"));
        boolean b11 = numericValidator1.validate("aaaa");
        Validator lowerCaseValidator1 = new Validator((String s) -> s.matches("\\d+"));
        boolean b21 = lowerCaseValidator.validate("bbbb");
        System.out.println(b11 + " " + b21);
    }
}

2.2 模板方法

模板 方法模式在你“希望使用這個算法，但是需要對其中的某些行進行改進，才能達到希望的效果” 時是非常有用的。

public abstract class OnlineBanking {
    public void processCustomer(int id) {
        Customer c = DataUtil.getCustomerWithId(id);
        makeCustomerHappy(c);
    }
    abstract void makeCustomerHappy(Customer c);
}
public class OnlineBankingLambda {
    public void processCustomer(int id, Consumer<Customer> consumer) {
        Customer c = DataUtil.getCustomerWithId(id);
        consumer.accept(c);
    }
}
public class TemplateMethod {
    public static void main(String[] args) {
        new OnlineBanking() {
            @Override
            void makeCustomerHappy(Customer c) {
                System.out.println(c.getName() + " happy!");
            }
        }.processCustomer(1);
        new OnlineBankingLambda().processCustomer(1, (Customer c) -> System.out.println(c.getName() + " happy!"));
    }
}

2.3 觀察者模式

觀察者模式是一種比較常見的方案，某些事件發(fā)生時(比如狀態(tài)轉(zhuǎn)變)，如果一個對象(通常我們稱之為主題)需要自動地通知其他多個對象(稱為觀察者)，就會采用該方案。

public interface Observer {
    void notify(String tweet);
}
public class NYTime implements Observer {
    @Override
    public void notify(String tweet) {
        if(tweet != null && tweet.contains("money")){
            System.out.println("Breaking news in NY! " + tweet);
        }
    }
}
public class Guardian implements Observer {
    @Override
    public void notify(String tweet) {
        if(tweet != null && tweet.contains("queen")){
            System.out.println("Yet another news in London... " + tweet);
        }
    }
}
public class LeMonde implements Observer {
    @Override
    public void notify(String tweet) {
        if(tweet != null && tweet.contains("wine")){
            System.out.println("Today cheese, wine and news! " + tweet);
        }
    }
}
public interface Subject {
    void registerObserver(Observer o);
    void nofityObservers(String tweet);
}
public class Feed implements Subject {
    private final List<Observer> observers = new ArrayList<>();
    @Override
    public void registerObserver(Observer o) {
        this.observers.add(o);
    }
    @Override
    public void nofityObservers(String tweet) {
        observers.forEach(o -> o.notify(tweet));
    }
}
public class ObserverDemo {
    public static void main(String[] args) {
        Feed f = new Feed();
        f.registerObserver(new NYTime());
        f.registerObserver(new Guardian());
        f.registerObserver(new LeMonde());
        f.nofityObservers("The queen said her favourite book is Java 8 in Action!");
        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);
            }
        });
    }
}

2.4 責(zé)任鏈模式

責(zé)任鏈模式是一種創(chuàng)建處理對象序列(比如操作序列)的通用方案。一個處理對象可能需要在完成一些工作之后，將結(jié)果傳遞給另一個對象，這個對象接著做一些工作，再轉(zhuǎn)交給下一個處理對象，以此類推。

public abstract class ProcessingObject<T> {
    protected ProcessingObject<T> successor;
    public void setSuccessor(ProcessingObject<T> 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<String> {
    @Override
    protected String handleWork(String input) {
        return "From Raoul, Mario and Alan: " + input;
    }
}
public class SpellCheckerProcessing extends ProcessingObject<String> {
    @Override
    protected String handleWork(String input) {
        return input.replaceAll("labda", "lambda");
    }
}
public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        ProcessingObject<String> p1 = new HeaderTextProcessing();
        ProcessingObject<String> p2 = new SpellCheckerProcessing();
        p1.setSuccessor(p2);
        String result = p1.handle("Aren't labdas really sexy?!!");
        System.out.println(result);
        UnaryOperator<String> headerProcessing = (String text) -> "From Raoul, Mario and Alan: " + text;
        UnaryOperator<String> spellCheckerProcessing = (String text) -> text.replaceAll("labda", "lambda");
        Function<String, String> pipeline = headerProcessing.andThen(spellCheckerProcessing);
        String result1 = pipeline.apply("Aren't labdas really sexy?!!");
        System.out.println(result1);
    }
}

2.5 工廠模式

使用工廠模式，你無需向客戶暴露實例化的邏輯就能完成對象的創(chuàng)建。

public interface Product {}
@Data
public class Loan implements Product {}
@Data
public class Stock implements Product {}
@Data
public class Bond implements Product {}
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);
        }
    }
    public static void main(String[] args) {
        Product p = ProductFactory.createProduct("loan");
        System.out.println(p);
    }
}
public class ProductFactoryLambda {
    private final static Map<String, Supplier<Product>> map = new HashMap<>();
    static {
        map.put("loan", Loan::new);
        map.put("stock", Stock::new);
        map.put("bond", Bond::new);
    }
    public static Product createProduct(String name) {
        Supplier<Product> p = map.get(name);
        if (p != null) {
            return p.get();
        }
        throw new IllegalArgumentException("No such product " + name);
    }
    public static void main(String[] args) {
        Product p = ProductFactoryLambda.createProduct("loan");
        System.out.println(p);
    }
}

3. 測試Lambda表達式

略

4. 調(diào)試Lambda表達式

4.1 查看棧跟蹤

public class Debugging{ 11 public static void main(String[] args) {
        List<Point> points = Arrays.asList(new Point(12, 2), null);
        points.stream().map(p -> p.getX()).forEach(System.out::println); }
}
運行這段代碼會產(chǎn)生下面的棧跟蹤:
Exception in thread "main" java.lang.NullPointerException
at Debugging.lambda$main$0(Debugging.java:6)
at Debugging$$Lambda$5/284720968.apply(Unknown Source)
at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline
.java:193)
at java.util.Spliterators$ArraySpliterator.forEachRemaining(Spliterators
.java:948)

我們需要特別注意，涉及Lambda表達式的棧????可能非常難理解。這是Java編譯器未來版本可以改進的一個方面。

4.2 使用日志調(diào)試

peek的設(shè)計初衷就是在流的每個元素恢復(fù)運行之前，插入執(zhí)行一個動作。但是它不像forEach那樣恢復(fù)整個流的運行，而是在一個元素上完成操作之后，它只會將操作順承到流水線中的下一個操作。圖8-4解釋了peek的操作流程。

List<Integer> result = numbers.stream()
         .peek(x -> System.out.println("from stream: " + x))
         .map(x -> x + 17)
         .peek(x -> System.out.println("after map: " + x))
         .filter(x -> x % 2 == 0)
         .peek(x -> System.out.println("after filter: " + x))
         .limit(3)
         .peek(x -> System.out.println("after limit: " + x))
         .collect(toList());
輸出結(jié)果：
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

5. 小結(jié)

• Lambda表達式能提升代碼的可讀性和靈活性。
• 如果你的代碼中使用了匿名類，盡量用Lambda表達式替換它們，但是要注意二者間語義的微妙差別，比如關(guān)鍵字this，以及變量隱藏。
• Lambda表達式比起來，方法引用的可讀性更好。
• 盡量使用Stream API替換迭代式的集合處理。
• Lambda表達式有助于避免使用面向?qū)ο笤O(shè)計模式時容易出現(xiàn)的??化的模板代碼，典型的比如策略模式、模板方法、觀察者模式、責(zé)任鏈模式，以及工廠模式。
• 即使采用了Lambda表達式，也同樣可以進行單元測試，但是通常你應(yīng)該關(guān)注使用了Lambda表達式的方法的行為。
• 盡量將復(fù)雜的Lambda表達式抽象到普通方法中。
• Lambda表達式會讓棧跟蹤的分析變得更為復(fù)雜。
• 流提供的peek方法在分析Stream流水線時，能將中間變量的值輸出到日志中，是非常有用的工具。

Tips

本文同步發(fā)表在公眾號，歡迎大家關(guān)注！??
后續(xù)筆記歡迎關(guān)注獲取第一時間更新！

公眾號二維碼.jpg