Technical proofing by Jean-Francois Morin

java8 · raoulDoc · Jun 29, 2014 · Jun 29, 2014 · Jun 29, 2014 · Jun 29, 2014
commit b0406376f6f1e4e4fbcdbc2e7ef6fc0a26b19233
diff --git a/src/main/java/lambdasinaction/chap10/AsyncShop.java b/src/main/java/lambdasinaction/chap10/AsyncShop.java
@@ -1,10 +1,11 @@
 package lambdasinaction.chap10;
 
-import java.text.*;
-import java.util.*;
-import java.util.concurrent.*;
+import static lambdasinaction.chap10.Util.delay;
+import static lambdasinaction.chap10.Util.format;
 
-import static lambdasinaction.chap10.Util.*;
+import java.util.Random;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Future;
 
 public class AsyncShop {
 

diff --git a/src/main/java/lambdasinaction/chap10/AsyncShopClient.java b/src/main/java/lambdasinaction/chap10/AsyncShopClient.java
@@ -1,6 +1,6 @@
 package lambdasinaction.chap10;
 
-import java.util.concurrent.*;
+import java.util.concurrent.Future;
 
 public class AsyncShopClient {
 

diff --git a/src/main/java/lambdasinaction/chap10/BestPriceFinder.java b/src/main/java/lambdasinaction/chap10/BestPriceFinder.java
@@ -1,8 +1,13 @@
 package lambdasinaction.chap10;
 
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.stream.*;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 public class BestPriceFinder {
 
@@ -20,68 +25,42 @@ public Thread newThread(Runnable r) {
             return t;
         }
     });
-/*
-    public List<String> findPriceSequential(String product) {
-        return shops.stream()
-                .map(shop -> shop.getName() + " price is " + shop.calculatePrice(product))
-                .collect(Collectors.toList());
-    }
-
-    public List<String> findPriceParallel(String product) {
-        return shops.parallelStream()
-                .map(shop -> shop.getName() + " price is " + shop.calculatePrice(product))
-                .collect(Collectors.toList());
-    }
-
-    public List<String> findPrice(String product) {
-        List<CompletableFuture<String>> priceFutures =
-                shops.stream()
-                .map(shop -> CompletableFuture.supplyAsync(() -> shop.getName() + " price is "
-                        + shop.calculatePrice(product), executor))
-                .collect(Collectors.toList());
 
-        List<String> prices = priceFutures.stream()
-                .map(CompletableFuture::join)
-                .collect(Collectors.toList());
-        return prices;
-        //return sequence(priceFutures).join();
-    }
-/*/
-    public List<String> findPriceSequential(String product) {
+    public List<String> findPricesSequential(String product) {
         return shops.stream()
                 .map(shop -> shop.getPrice(product))
                 .map(Quote::parse)
                 .map(Discount::applyDiscount)
                 .collect(Collectors.toList());
     }
 
-    public List<String> findPriceParallel(String product) {
+    public List<String> findPricesParallel(String product) {
         return shops.parallelStream()
                 .map(shop -> shop.getPrice(product))
                 .map(Quote::parse)
                 .map(Discount::applyDiscount)
                 .collect(Collectors.toList());
     }
 
-    public List<String> findPrice(String product) {
-        List<CompletableFuture<String>> priceFutures = findPriceStream(product)
+    public List<String> findPricesFuture(String product) {
+        List<CompletableFuture<String>> priceFutures = findPricesStream(product)
                 .collect(Collectors.<CompletableFuture<String>>toList());
 
         return priceFutures.stream()
                 .map(CompletableFuture::join)
                 .collect(Collectors.toList());
     }
 
-    public Stream<CompletableFuture<String>> findPriceStream(String product) {
+    public Stream<CompletableFuture<String>> findPricesStream(String product) {
         return shops.stream()
                 .map(shop -> CompletableFuture.supplyAsync(() -> shop.getPrice(product), executor))
                 .map(future -> future.thenApply(Quote::parse))
                 .map(future -> future.thenCompose(quote -> CompletableFuture.supplyAsync(() -> Discount.applyDiscount(quote), executor)));
     }
 
-    public void printPricesStream() {
+    public void printPricesStream(String product) {
         long start = System.nanoTime();
-        CompletableFuture[] futures = findPriceStream("myPhone")
+        CompletableFuture[] futures = findPricesStream(product)
                 .map(f -> f.thenAccept(s -> System.out.println(s + " (done in " + ((System.nanoTime() - start) / 1_000_000) + " msecs)")))
                 .toArray(size -> new CompletableFuture[size]);
         CompletableFuture.allOf(futures).join();

diff --git a/src/main/java/lambdasinaction/chap10/BestPriceFinderMain.java b/src/main/java/lambdasinaction/chap10/BestPriceFinderMain.java
@@ -1,20 +1,17 @@
 package lambdasinaction.chap10;
 
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.function.*;
-
-import static java.util.stream.Collectors.toList;
+import java.util.List;
+import java.util.function.Supplier;
 
 public class BestPriceFinderMain {
 
     private static BestPriceFinder bestPriceFinder = new BestPriceFinder();
 
     public static void main(String[] args) {
-        //execute("sequential", () -> bestPriceFinder.findPriceSequential("myPhone"));
-        //execute("parallel", () -> bestPriceFinder.findPriceParallel("myPhone"));
-        execute("composed CompletableFuture", () -> bestPriceFinder.findPrice("myPhone"));
-        //bestPriceFinder.printPricesStream();
+        execute("sequential", () -> bestPriceFinder.findPricesSequential("myPhone27S"));
+        execute("parallel", () -> bestPriceFinder.findPricesParallel("myPhone27S"));
+        execute("composed CompletableFuture", () -> bestPriceFinder.findPricesFuture("myPhone27S"));
+        bestPriceFinder.printPricesStream("myPhone27S");
     }
 
     private static void execute(String msg, Supplier<List<String>> s) {
@@ -23,4 +20,5 @@ private static void execute(String msg, Supplier<List<String>> s) {
         long duration = (System.nanoTime() - start) / 1_000_000;
         System.out.println(msg + " done in " + duration + " msecs");
     }
+
 }
diff --git a/src/main/java/lambdasinaction/chap10/Discount.java b/src/main/java/lambdasinaction/chap10/Discount.java
@@ -1,8 +1,7 @@
 package lambdasinaction.chap10;
 
-import java.util.*;
-
-import static lambdasinaction.chap10.Util.*;
+import static lambdasinaction.chap10.Util.delay;
+import static lambdasinaction.chap10.Util.format;
 
 public class Discount {
 

diff --git a/src/main/java/lambdasinaction/chap10/Shop.java b/src/main/java/lambdasinaction/chap10/Shop.java
@@ -1,8 +1,9 @@
 package lambdasinaction.chap10;
 
-import java.util.*;
+import static lambdasinaction.chap10.Util.delay;
+import static lambdasinaction.chap10.Util.format;
 
-import static lambdasinaction.chap10.Util.*;
+import java.util.Random;
 
 public class Shop {
 

diff --git a/src/main/java/lambdasinaction/chap10/Util.java b/src/main/java/lambdasinaction/chap10/Util.java
@@ -1,9 +1,12 @@
 package lambdasinaction.chap10;
 
-import java.text.*;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.stream.*;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.List;
+import java.util.Locale;
+import java.util.Random;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
 
 public class Util {
 

diff --git a/src/main/java/lambdasinaction/chap11/DateTimeExamples.java b/src/main/java/lambdasinaction/chap11/DateTimeExamples.java
@@ -1,15 +1,27 @@
 package lambdasinaction.chap11;
 
-import java.text.*;
-import java.time.*;
-import java.time.chrono.*;
-import java.time.format.*;
-import java.time.temporal.*;
-import java.util.*;
-
-import static java.time.temporal.ChronoField.DAY_OF_WEEK;
-import static java.time.temporal.ChronoUnit.DAYS;
-import static java.time.temporal.TemporalAdjusters.*;
+import static java.time.temporal.TemporalAdjusters.lastDayOfMonth;
+import static java.time.temporal.TemporalAdjusters.nextOrSame;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.time.DayOfWeek;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Month;
+import java.time.chrono.JapaneseDate;
+import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.temporal.ChronoField;
+import java.time.temporal.ChronoUnit;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAdjuster;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
 
 public class DateTimeExamples {
 
@@ -20,9 +32,9 @@ protected DateFormat initialValue() {
     };
 
     public static void main(String[] args) {
-        //useOldDate();
+        useOldDate();
         useLocalDate();
-        //useTemporalAdjuster();
+        useTemporalAdjuster();
         useDateFormatter();
     }
 
@@ -33,7 +45,7 @@ private static void useOldDate() {
         System.out.println(formatters.get().format(date));
 
         Calendar calendar = Calendar.getInstance();
-        calendar.set(2014, 2, 18);
+        calendar.set(2014, Calendar.FEBRUARY, 18);
         System.out.println(calendar);
     }
 
@@ -101,22 +113,22 @@ private static void useTemporalAdjuster() {
         date = date.with(nextOrSame(DayOfWeek.FRIDAY));
         System.out.println(date);
         date = date.with(temporal -> {
-            int dow = temporal.get(DAY_OF_WEEK);
+            DayOfWeek dow = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));
             int dayToAdd = 1;
-            if (dow == 5) dayToAdd = 3;
-            if (dow == 6) dayToAdd = 2;
-            return temporal.plus(dayToAdd, DAYS);
+            if (dow == DayOfWeek.FRIDAY) dayToAdd = 3;
+            if (dow == DayOfWeek.SATURDAY) dayToAdd = 2;
+            return temporal.plus(dayToAdd, ChronoUnit.DAYS);
         });
         System.out.println(date);
     }
 
     private static class NextWorkingDay implements TemporalAdjuster {
         @Override
         public Temporal adjustInto(Temporal temporal) {
-            int dow = temporal.get(ChronoField.DAY_OF_WEEK);
+            DayOfWeek dow = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));
             int dayToAdd = 1;
-            if (dow == 5) dayToAdd = 3;
-            if (dow == 6) dayToAdd = 2;
+            if (dow == DayOfWeek.FRIDAY) dayToAdd = 3;
+            if (dow == DayOfWeek.SATURDAY) dayToAdd = 2;
             return temporal.plus(dayToAdd, ChronoUnit.DAYS);
         }
     }

diff --git a/src/main/java/lambdasinaction/chap12/SubsetsMain.java b/src/main/java/lambdasinaction/chap12/SubsetsMain.java
@@ -5,17 +5,13 @@
 import java.util.Collections;
 import java.util.List;
 
-
 public class SubsetsMain {
 
     public static void main(String[] args) {
         List<List<Integer>> subs = subsets(Arrays.asList(1, 4, 9));
-
         subs.forEach(System.out::println);
-
     }
 
-
     public static List<List<Integer>> subsets(List<Integer> l) {
         if (l.isEmpty()) {
             List<List<Integer>> ans = new ArrayList<>();
@@ -30,9 +26,11 @@ public static List<List<Integer>> subsets(List<Integer> l) {
     }
 
     public static List<List<Integer>> insertAll(Integer first, List<List<Integer>> lists) {
-        List<List<Integer>> result = new ArrayList<>(); for (List<Integer> l : lists) {
-            List<Integer> copyList = new ArrayList<>(l);
+        List<List<Integer>> result = new ArrayList<>();
+        for (List<Integer> l : lists) {
+            List<Integer> copyList = new ArrayList<>();
             copyList.add(first);
+            copyList.addAll(l);
             result.add(copyList);
         }
         return result;

diff --git a/src/main/java/lambdasinaction/chap13/Combinators.java b/src/main/java/lambdasinaction/chap13/Combinators.java
@@ -1,19 +1,18 @@
 package lambdasinaction.chap13;
 
-
 import java.util.function.Function;
 
 public class Combinators {
 
     public static void main(String[] args) {
-        System.out.println(repeat(3, (Integer x)->2*x).apply(10));
+        System.out.println(repeat(3, (Integer x) -> 2 * x).apply(10));
     }
 
-    static <A,B,C> Function<A,C> compose(Function<B,C> g, Function<A,B> f) {
+    static <A, B, C> Function<A, C> compose(Function<B, C> g, Function<A, B> f) {
         return x -> g.apply(f.apply(x));
     }
 
-    static <A> Function<A,A> repeat(int n, Function<A,A> f) {
-        return n==0?x->x : compose(f, (Function<A,A>) repeat(n-1, f));
+    static <A> Function<A, A> repeat(int n, Function<A, A> f) {
+        return n == 0 ? x -> x : compose(f, repeat(n - 1, f));
     }
 }
diff --git a/src/main/java/lambdasinaction/chap13/Currying.java b/src/main/java/lambdasinaction/chap13/Currying.java
@@ -13,6 +13,9 @@ public static void main(String[] args) {
         System.out.println(convertCtoF.applyAsDouble(24));
         System.out.println(convertUSDtoGBP.applyAsDouble(100));
         System.out.println(convertKmtoMi.applyAsDouble(20));
+
+        DoubleUnaryOperator convertFtoC = expandedCurriedConverter(-32, 5.0/9, 0);
+        System.out.println(convertFtoC.applyAsDouble(98.6));
     }
 
     static double converter(double x, double y, double z) {
@@ -23,4 +26,7 @@ static DoubleUnaryOperator curriedConverter(double y, double z) {
         return (double x) -> x * y + z;
     }
 
+    static DoubleUnaryOperator expandedCurriedConverter(double w, double y, double z) {
+        return (double x) -> (x + w) * y + z;
+    }
 }