[add] add refactor and debug techniques in Java 8 module.

brianway · brianway · commit 0529ac2b7107 · 2017-03-24T21:53:19.000+08:00
diff --git a/java8/README.md b/java8/README.md
@@ -45,3 +45,13 @@
 - ParallelStreams: 并行流计算 1~n 的和,分别使用指令式,串行迭代流,并行迭代流,基本类型流,有副作用的流
 - ForkJoinSumCalculator: 使用分支/合并框架执行并行求和
 - WordCount: Spliterator: splitable iterator
+
+## 高效 Java 8 编程
+
+- StrategyMain: 策略模式
+- TemplateMain: 模版方法
+- ObserverMain: 观察者模式
+- ChainOfResponsibilityMain: 责任链模式
+- FactoryMain: 工厂模式
+- Debugging: 查看栈跟踪
+- Peek: 使用日志调试
diff --git a/java8/src/main/java/com/brianway/learning/java8/effective/tech/ChainOfResponsibilityMain.java b/java8/src/main/java/com/brianway/learning/java8/effective/tech/ChainOfResponsibilityMain.java
@@ -0,0 +1,62 @@
+package com.brianway.learning.java8.effective.tech;
+
+import java.util.function.Function;
+import java.util.function.UnaryOperator;
+
+/**
+ * 责任链模式
+ */
+public class ChainOfResponsibilityMain {
+
+    public static void main(String[] args) {
+        //old school
+        ProcessingObject<String> p1 = new HeaderTextProcessing();
+        ProcessingObject<String> p2 = new SpellCheckerProcessing();
+        p1.setSuccessor(p2);
+        String result1 = p1.handle("Aren't labdas really sexy?!!");
+        System.out.println(result1);
+
+        // with lambdas
+        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 result2 = pipeline.apply("Aren't labdas really sexy?!!");
+        System.out.println(result2);
+    }
+
+    static private 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);
+    }
+
+    static private class HeaderTextProcessing
+            extends ProcessingObject<String> {
+        public String handleWork(String text) {
+            return "From Raoul, Mario and Alan: " + text;
+        }
+    }
+
+    static private class SpellCheckerProcessing
+            extends ProcessingObject<String> {
+        public String handleWork(String text) {
+            return text.replaceAll("labda", "lambda");
+        }
+    }
+}
+
+
diff --git a/java8/src/main/java/com/brianway/learning/java8/effective/tech/Debugging.java b/java8/src/main/java/com/brianway/learning/java8/effective/tech/Debugging.java
@@ -0,0 +1,41 @@
+package com.brianway.learning.java8.effective.tech;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 查看栈跟踪
+ */
+public class Debugging {
+    public static void main(String[] args) {
+//        Arrays.asList(1, 2, 3).stream()
+//                .map(Debugging::divideByZero)
+//                .forEach(System.out::println);
+
+        List<Point> points = Arrays.asList(new Point(12, 2), null);
+        //points.stream().map(p -> p.getX()).forEach(System.out::println);
+        points.stream().map(Point::getX).forEach(System.out::println);
+    }
+
+    private static class Point {
+        private int x;
+        private int y;
+
+        private Point(int x, int y) {
+            this.x = x;
+            this.y = y;
+        }
+
+        public int getX() {
+            return x;
+        }
+
+        public void setX(int x) {
+            this.x = x;
+        }
+    }
+
+    public static int divideByZero(int n) {
+        return n / 0;
+    }
+}
diff --git a/java8/src/main/java/com/brianway/learning/java8/effective/tech/FactoryMain.java b/java8/src/main/java/com/brianway/learning/java8/effective/tech/FactoryMain.java
@@ -0,0 +1,68 @@
+package com.brianway.learning.java8.effective.tech;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
+/**
+ * 工厂模式
+ */
+public class FactoryMain {
+
+    public static void main(String[] args) {
+        Product p1 = ProductFactory.createProduct("loan");
+        p1.printClassName();
+
+        // with lambdas
+        Supplier<Product> loanSupplier = Loan::new;
+        Product p2 = loanSupplier.get();
+        p2.printClassName();
+
+        Product p3 = ProductFactory.createProductLambda("loan");
+        p3.printClassName();
+    }
+
+    static private 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 Product createProductLambda(String name) {
+            Supplier<Product> p = map.get(name);
+            if (p != null) return p.get();
+            throw new RuntimeException("No such product " + name);
+        }
+    }
+
+    private interface Product {
+        default void printClassName() {
+            System.out.println(getClass().getSimpleName());
+        }
+    }
+
+    static private class Loan implements Product {
+    }
+
+    static private class Stock implements Product {
+    }
+
+    static private class Bond implements Product {
+    }
+
+    final static private Map<String, Supplier<Product>> map = new HashMap<>();
+
+    static {
+        map.put("loan", Loan::new);
+        map.put("stock", Stock::new);
+        map.put("bond", Bond::new);
+    }
+}
diff --git a/java8/src/main/java/com/brianway/learning/java8/effective/tech/ObserverMain.java b/java8/src/main/java/com/brianway/learning/java8/effective/tech/ObserverMain.java
@@ -0,0 +1,86 @@
+package com.brianway.learning.java8.effective.tech;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 观察者模式
+ */
+public class ObserverMain {
+
+    public static void main(String[] args) {
+        //old school
+        Subject 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!");
+
+        // with lambdas
+        Feed feedLambda = new Feed();
+
+        feedLambda.registerObserver((String tweet) -> {
+            if (tweet != null && tweet.contains("money")) {
+                System.out.println("Breaking news in NY! " + tweet);
+            }
+        });
+        feedLambda.registerObserver((String tweet) -> {
+            if (tweet != null && tweet.contains("queen")) {
+                System.out.println("Yet another news in London... " + tweet);
+            }
+        });
+
+        feedLambda.notifyObservers("Money money money, give me money!");
+
+    }
+
+    interface Observer {
+        void inform(String tweet);
+    }
+
+    interface Subject {
+        void registerObserver(Observer o);
+
+        void notifyObservers(String tweet);
+    }
+
+    static private class NYTimes implements Observer {
+        @Override
+        public void inform(String tweet) {
+            if (tweet != null && tweet.contains("money")) {
+                System.out.println("Breaking news in NY!" + tweet);
+            }
+        }
+    }
+
+    static private class Guardian implements Observer {
+        @Override
+        public void inform(String tweet) {
+            if (tweet != null && tweet.contains("queen")) {
+                System.out.println("Yet another news in London... " + tweet);
+            }
+        }
+    }
+
+    static private class LeMonde implements Observer {
+        @Override
+        public void inform(String tweet) {
+            if (tweet != null && tweet.contains("wine")) {
+                System.out.println("Today cheese, wine and news! " + tweet);
+            }
+        }
+    }
+
+    static private 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.inform(tweet));
+        }
+    }
+
+}
diff --git a/java8/src/main/java/com/brianway/learning/java8/effective/tech/Peek.java b/java8/src/main/java/com/brianway/learning/java8/effective/tech/Peek.java
@@ -0,0 +1,25 @@
+package com.brianway.learning.java8.effective.tech;
+
+import static java.util.stream.Collectors.toList;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * 使用日志调试
+ */
+public class Peek {
+
+    public static void main(String[] args) {
+
+        List<Integer> result = Stream.of(2, 3, 4, 5)
+                .peek(x -> System.out.println("taking 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());
+    }
+}
diff --git a/java8/src/main/java/com/brianway/learning/java8/effective/tech/StrategyMain.java b/java8/src/main/java/com/brianway/learning/java8/effective/tech/StrategyMain.java
@@ -0,0 +1,49 @@
+package com.brianway.learning.java8.effective.tech;
+
+/**
+ * 策略模式
+ */
+public class StrategyMain {
+
+    public static void main(String[] args) {
+        // old school
+        Validator v1 = new Validator(new IsNumeric());
+        System.out.println(v1.validate("aaaa"));
+        Validator v2 = new Validator(new IsAllLowerCase());
+        System.out.println(v2.validate("bbbb"));
+
+        // with lambdas
+        Validator v3 = new Validator((String s) -> s.matches("\\d+"));
+        System.out.println(v3.validate("aaaa"));
+        Validator v4 = new Validator((String s) -> s.matches("[a-z]+"));
+        System.out.println(v4.validate("bbbb"));
+    }
+
+    interface ValidationStrategy {
+        boolean execute(String s);
+    }
+
+    static private class IsAllLowerCase implements ValidationStrategy {
+        public boolean execute(String s) {
+            return s.matches("[a-z]+");
+        }
+    }
+
+    static private class IsNumeric implements ValidationStrategy {
+        public boolean execute(String s) {
+            return s.matches("\\d+");
+        }
+    }
+
+    static private class Validator {
+        private final ValidationStrategy strategy;
+
+        public Validator(ValidationStrategy v) {
+            this.strategy = v;
+        }
+
+        public boolean validate(String s) {
+            return strategy.execute(s);
+        }
+    }
+}
diff --git a/java8/src/main/java/com/brianway/learning/java8/effective/tech/TemplateMain.java b/java8/src/main/java/com/brianway/learning/java8/effective/tech/TemplateMain.java
