3分钟看完Java 8——史上最强Java 8新特性总结之第三篇 函数式编程技巧

目录

· 改写设计模式

    · 策略模式（Strategy Pattern）

    · 模板方法模式（Template Method Pattern）

    · 观察者模式（Observer Pattern）

    · 责任链模式（Chain of Responsibility Pattern）

    · 简单工厂模式（Simple Factory Pattern）

· 高阶函数与柯里化

---

 

改写设计模式

策略模式（Strategy Pattern）

1. 改写前

    a) ValidationStrategy.java

public interface ValidationStrategy {

    boolean execute(String s);

}

    b) IsNumeric.java

public class IsNumeric implements ValidationStrategy {

    public boolean execute(String s) {
        return s.matches("\\d+");
    }

}

    c) IsAllLowerCase.java

public class IsAllLowerCase implements ValidationStrategy {

    public boolean execute(String s) {
        return s.matches("[a-z]+");
    }

}

    d) Validator.java

public class Validator {
    private final ValidationStrategy strategy;

    public Validator(ValidationStrategy v) {
        this.strategy = v;
    }

    public boolean validate(String s) {
        return strategy.execute(s);
    }
}

    e) Test.java

public class Test {

    public static void main(String[] args) {
        Validator numericValidator = new Validator(new IsNumeric());
        boolean b1 = numericValidator.validate("aaaa");
        System.out.println(b1); // false
        Validator lowerCaseValidator = new Validator(new IsAllLowerCase());
        boolean b2 = lowerCaseValidator.validate("bbbb");
        System.out.println(b2); // true
    }

}

2.改写后

    a) Test.java

public class Test {

    public static void main(String[] args) {
        Validator numericValidator = new Validator((String s) -> s.matches("\\d+"));
        boolean b1 = numericValidator.validate("aaaa");
        System.out.println(b1); // false
        Validator lowerCaseValidator = new Validator(s -> s.matches("[a-z]+"));
        boolean b2 = lowerCaseValidator.validate("bbbb");
        System.out.println(b2); // true
    }

}

模板方法模式（Template Method Pattern）

1. 改写前

    a) Customer.java

public class Customer {

    private int id;
    private String name;

    public Customer(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

    b) OnlineBanking.java

public abstract class OnlineBanking {

    public void processCustomer(int id) {
        Customer c = new Customer(id, "Jhon");
        makeCustomerHappy(c);
    }

    abstract void makeCustomerHappy(Customer c);

}

2.改写后

    a) OnlineBankingLambda.java

import java.util.function.Consumer;

public class OnlineBankingLambda {

    public void processCustomer(int id, Consumer<Customer> makeCustomerHappy) {
        Customer c = new Customer(id, "Jhon");
        makeCustomerHappy.accept(c);
    }

}

    b) Test.java

public class Test {

    public static void main(String[] args) {
        new OnlineBankingLambda().processCustomer(1337, (Customer c) -> System.out.println("Hello " + c.getName()));
    }

}

观察者模式（Observer Pattern）

1. 改写前

    a) Observer.java

public interface Observer {

    void notify(String tweet);

}

    b) NYTimes.java

public class NYTimes implements Observer {

    public void notify(String tweet) {
        if (tweet != null && tweet.contains("money")) {
            System.out.println("Breaking news in NY! " + tweet);
        }
    }

}

    c) Guardian.java

public class Guardian implements Observer {

    public void notify(String tweet) {
        if (tweet != null && tweet.contains("queen")) {
            System.out.println("Yet another news in London... " + tweet);
        }
    }

}

    d) LeMonde.java

public class LeMonde implements Observer {

    public void notify(String tweet) {
        if (tweet != null && tweet.contains("wine")) {
            System.out.println("Today cheese, wine and news! " + tweet);
        }
    }

}

    e) Subject.java

public interface Subject {

    void registerObserver(Observer o);

    void notifyObservers(String tweet);

}

    f) Feed.java

public class Feed implements Subject {

    private final List<Observer> observers = new ArrayList<>();

    public void registerObserver(Observer o) {
        this.observers.add(o);
    }

    public void notifyObservers(String tweet) {
        observers.forEach(o -> o.notify(tweet));
    }

}

    g) Test.java

public class Test {

    public static void main(String[] args) {
        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!");
    }

}

2.改写后

    a) Test.java

public class Test {

    public static void main(String[] args) {
        Feed f = new Feed();
        f.registerObserver((String tweet) -> {
            if (tweet != null && tweet.contains("money")) {
                System.out.println("Breaking news in NY! " + tweet);
            }
        });
        f.registerObserver((tweet) -> {
            if (tweet != null && tweet.contains("queen")) {
                System.out.println("Yet another news in London... " + tweet);
            }
        });
        f.registerObserver((tweet) -> {
            if (tweet != null && tweet.contains("wine")) {
                System.out.println("Today cheese, wine and news! " + tweet);
            }
        });
        f.notifyObservers("The queen said her favourite book is Java 8 in Action!");
    }

}

责任链模式（Chain of Responsibility Pattern）

1. 改写前

    a) ProcessingObject.java

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;
    }

    protected abstract T handleWork(T input);
}

    b) HeaderTextProcessing.java

public class HeaderTextProcessing extends ProcessingObject<String> {

    public String handleWork(String text) {
        return "From Raoul, Mario and Alan: " + text;
    }

}

    c) SpellCheckerProcessing.java

public class SpellCheckerProcessing extends ProcessingObject<String> {

    public String handleWork(String text) {
        return text.replaceAll("labda", "lambda");
    }

}

    d) Test.java

public class Test {

    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);
    }

}

2.改写后

    a) Test.java

public class Test {

    public static void main(String[] args) {
        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 result = pipeline.apply("Aren't labdas really sexy?!!");
        System.out.println(result);
    }

}

简单工厂模式（Simple Factory Pattern）

1. 改写前

    a) Product.java

public interface Product {
}

    b) Loan.java

public class Loan implements Product {
}

    c) Stock.java

public class Stock implements Product {
}

    d) Bond.java

public class Bond implements Product {
}

    e) ProductFactory.java

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);
        }
    }

}

    f) Test.java

public class Test {

    public static void main(String[] args) {
        Product p = ProductFactory.createProduct("loan");
    }

}

2. 改写后

    a) ProductFactory.java

import java.util.HashMap;
import java.util.Map;
import java.util.function.Supplier;

public class ProductFactory {

    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);
    }

}

    b) Test.java

public class Test {

    public static void main(String[] args) {
        Product p = ProductFactory.createProduct("loan");
    }

}

高阶函数与柯里化

1. 高阶函数（Higher-order Function）：满足以下任意一个条件都是高阶函数。

    a) 接受至少一个函数作为参数。

    b) 返回的结果是一个函数。

2. 柯里化（Currying）：假设有一个函数 f(x, y) ，柯里化就是把多个参数的函数f转化为一个参数的函数g，并且函数g的返回值一个新函数，即 f(x, y) = (g(x))(y) 。

3. 柯里化好处：灵活、复用。

4. 举例

    a) 柯里化前

public class Test {

    public static double converter(double x, double f, double b) {
        return x * f + b;
    }

    public static void main(String[] args) {
        double gbp = converter(1000, 0.6, 0);
        System.out.println(gbp);
    }

}

    b) 柯里化后

public class Test {

    public static DoubleUnaryOperator curriedConverter(double f, double b) {
        return (double x) -> x * f + b;
    }

    public static void main(String[] args) {
        DoubleUnaryOperator convertCtoF = curriedConverter(9.0 / 5, 32);
        DoubleUnaryOperator convertUSDtoGBP = curriedConverter(0.6, 0);
        DoubleUnaryOperator convertKmtoMi = curriedConverter(0.6214, 0);

        double gbp = convertUSDtoGBP.applyAsDouble(1000);
        System.out.println(gbp);
    }

}

 

作者：netoxi
出处：http://www.cnblogs.com/netoxi
本文版权归作者和博客园共有，欢迎转载，未经同意须保留此段声明，且在文章页面明显位置给出原文连接。欢迎指正与交流。