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
本文版权归作者和博客园共有，欢迎转载，未经同意须保留此段声明，且在文章页面明显位置给出原文连接。欢迎指正与交流。