From 73251635d40bc4ebc45b1be4e551cf655e610479 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Fran=C3=A7ois=20Morin?= Date: Sat, 28 Jun 2014 21:57:52 -0400 Subject: [PATCH 01/12] Technical proofing by Jean-Francois Morin --- .../chap10/ExchangeService.java | 26 ++++++ .../chap13/PersistentTrainJourney.java | 66 +++++++++++++++ .../chap13/PersistentTree.java | 82 +++++++++++++++++++ 3 files changed, 174 insertions(+) create mode 100644 src/main/java/lambdasinaction/chap10/ExchangeService.java create mode 100644 src/main/java/lambdasinaction/chap13/PersistentTrainJourney.java create mode 100644 src/main/java/lambdasinaction/chap13/PersistentTree.java diff --git a/src/main/java/lambdasinaction/chap10/ExchangeService.java b/src/main/java/lambdasinaction/chap10/ExchangeService.java new file mode 100644 index 00000000..9ae1ccdb --- /dev/null +++ b/src/main/java/lambdasinaction/chap10/ExchangeService.java @@ -0,0 +1,26 @@ +package lambdasinaction.chap10; + +import static lambdasinaction.chap10.Util.delay; + +public class ExchangeService { + + public enum Money { + USD(1.0), EUR(1.35387), GBP(1.69715), CAD(.92106), MXN(.07683); + + private final double rate; + + Money(double rate) { + this.rate = rate; + } + } + + public static double getRate(Money source, Money destination) { + return getRateWithDelay(source, destination); + } + + private static double getRateWithDelay(Money source, Money destination) { + delay(); + return destination.rate / source.rate; + } + +} diff --git a/src/main/java/lambdasinaction/chap13/PersistentTrainJourney.java b/src/main/java/lambdasinaction/chap13/PersistentTrainJourney.java new file mode 100644 index 00000000..8569f57f --- /dev/null +++ b/src/main/java/lambdasinaction/chap13/PersistentTrainJourney.java @@ -0,0 +1,66 @@ +package lambdasinaction.chap13; + +import java.util.function.Consumer; + +public class PersistentTrainJourney { + + public static void main(String[] args) { + TrainJourney tj1 = new TrainJourney(40, new TrainJourney(30, null)); + TrainJourney tj2 = new TrainJourney(20, new TrainJourney(50, null)); + + TrainJourney appended = append(tj1, tj2); + visit(appended, tj -> { System.out.print(tj.price + " - "); }); + System.out.println(); + + // A new TrainJourney is created without altering tj1 and tj2. + TrainJourney appended2 = append(tj1, tj2); + visit(appended2, tj -> { System.out.print(tj.price + " - "); }); + System.out.println(); + + // tj1 is altered but it's still not visible in the results. + TrainJourney linked = link(tj1, tj2); + visit(linked, tj -> { System.out.print(tj.price + " - "); }); + System.out.println(); + + // ... but here, if this code is uncommented, tj2 will be appended + // at the end of the already altered tj1. This will cause a + // StackOverflowError from the endless visit() recursive calls on + // the tj2 part of the twice altered tj1. + /*TrainJourney linked2 = link(tj1, tj2); + visit(linked2, tj -> { System.out.print(tj.price + " - "); }); + System.out.println();*/ + } + + static class TrainJourney { + public int price; + public TrainJourney onward; + + public TrainJourney(int p, TrainJourney t) { + price = p; + onward = t; + } + } + + static TrainJourney link(TrainJourney a, TrainJourney b) { + if (a == null) { + return b; + } + TrainJourney t = a; + while (t.onward != null) { + t = t.onward; + } + t.onward = b; + return a; + } + + static TrainJourney append(TrainJourney a, TrainJourney b) { + return a == null ? b : new TrainJourney(a.price, append(a.onward, b)); + } + + static void visit(TrainJourney journey, Consumer c) { + if (journey != null) { + c.accept(journey); + visit(journey.onward, c); + } + } +} diff --git a/src/main/java/lambdasinaction/chap13/PersistentTree.java b/src/main/java/lambdasinaction/chap13/PersistentTree.java new file mode 100644 index 00000000..e6b88b70 --- /dev/null +++ b/src/main/java/lambdasinaction/chap13/PersistentTree.java @@ -0,0 +1,82 @@ +package lambdasinaction.chap13; + +public class PersistentTree { + + public static void main(String[] args) { + Tree t = new Tree("Mary", 22, + new Tree("Emily", 20, + new Tree("Alan", 50, null, null), + new Tree("Georgie", 23, null, null) + ), + new Tree("Tian", 29, + new Tree("Raoul", 23, null, null), + null + ) + ); + + // found = 23 + System.out.println(lookup("Raoul", -1, t)); + // not found = -1 + System.out.println(lookup("Jeff", -1, t)); + + Tree f = fupdate("Jeff", 80, t); + // found = 80 + System.out.println(lookup("Jeff", -1, f)); + + Tree u = update("Jim", 40, t); + // t was not altered by fupdate, so Jeff is not found = -1 + System.out.println(lookup("Jeff", -1, u)); + // found = 40 + System.out.println(lookup("Jim", -1, u)); + + Tree f2 = fupdate("Jeff", 80, t); + // found = 80 + System.out.println(lookup("Jeff", -1, f2)); + // f2 built from t altered by update() above, so Jim is still present = 40 + System.out.println(lookup("Jim", -1, f2)); + } + + static class Tree { + private String key; + private int val; + private Tree left, right; + + public Tree(String k, int v, Tree l, Tree r) { + key = k; + val = v; + left = l; + right = r; + } + } + + public static int lookup(String k, int defaultval, Tree t) { + if (t == null) + return defaultval; + if (k.equals(t.key)) + return t.val; + return lookup(k, defaultval, k.compareTo(t.key) < 0 ? t.left : t.right); + } + + public static Tree update(String k, int newval, Tree t) { + if (t == null) + t = new Tree(k, newval, null, null); + else if (k.equals(t.key)) + t.val = newval; + else if (k.compareTo(t.key) < 0) + t.left = update(k, newval, t.left); + else + t.right = update(k, newval, t.right); + return t; + } + + public static Tree fupdate(String k, int newval, Tree t) { + return (t == null) ? + new Tree(k, newval, null, null) : + k.equals(t.key) ? + new Tree(k, newval, t.left, t.right) : + k.compareTo(t.key) < 0 ? + new Tree(t.key, t.val, fupdate(k,newval, t.left), t.right) : + new Tree(t.key, t.val, t.left, fupdate(k,newval, t.right)); + } + +} From b0406376f6f1e4e4fbcdbc2e7ef6fc0a26b19233 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Fran=C3=A7ois=20Morin?= Date: Sat, 28 Jun 2014 22:06:11 -0400 Subject: [PATCH 02/12] Technical proofing by Jean-Francois Morin --- .../lambdasinaction/chap10/AsyncShop.java | 9 +- .../chap10/AsyncShopClient.java | 2 +- .../chap10/BestPriceFinder.java | 51 ++----- .../chap10/BestPriceFinderMain.java | 16 +-- .../java/lambdasinaction/chap10/Discount.java | 5 +- .../java/lambdasinaction/chap10/Shop.java | 5 +- .../java/lambdasinaction/chap10/Util.java | 11 +- .../chap11/DateTimeExamples.java | 52 ++++--- .../lambdasinaction/chap12/SubsetsMain.java | 10 +- .../lambdasinaction/chap13/Combinators.java | 9 +- .../java/lambdasinaction/chap13/Currying.java | 6 + .../lambdasinaction/chap13/LazyLists.java | 56 ++++---- .../chap13/PatternMatching.java | 131 ++++++++++++++++-- .../java/lambdasinaction/chap4/Mapping.java | 4 +- .../java/lambdasinaction/chap5/Grouping.java | 4 +- 15 files changed, 236 insertions(+), 135 deletions(-) diff --git a/src/main/java/lambdasinaction/chap10/AsyncShop.java b/src/main/java/lambdasinaction/chap10/AsyncShop.java index 0813e63d..4d230e7d 100644 --- 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 index 297c24d5..029e9b30 100644 --- 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 index 15a75671..25cf3870 100644 --- 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,34 +25,8 @@ public Thread newThread(Runnable r) { return t; } }); -/* - public List findPriceSequential(String product) { - return shops.stream() - .map(shop -> shop.getName() + " price is " + shop.calculatePrice(product)) - .collect(Collectors.toList()); - } - - public List findPriceParallel(String product) { - return shops.parallelStream() - .map(shop -> shop.getName() + " price is " + shop.calculatePrice(product)) - .collect(Collectors.toList()); - } - - public List findPrice(String product) { - List> priceFutures = - shops.stream() - .map(shop -> CompletableFuture.supplyAsync(() -> shop.getName() + " price is " - + shop.calculatePrice(product), executor)) - .collect(Collectors.toList()); - List prices = priceFutures.stream() - .map(CompletableFuture::join) - .collect(Collectors.toList()); - return prices; - //return sequence(priceFutures).join(); - } -/*/ - public List findPriceSequential(String product) { + public List findPricesSequential(String product) { return shops.stream() .map(shop -> shop.getPrice(product)) .map(Quote::parse) @@ -55,7 +34,7 @@ public List findPriceSequential(String product) { .collect(Collectors.toList()); } - public List findPriceParallel(String product) { + public List findPricesParallel(String product) { return shops.parallelStream() .map(shop -> shop.getPrice(product)) .map(Quote::parse) @@ -63,8 +42,8 @@ public List findPriceParallel(String product) { .collect(Collectors.toList()); } - public List findPrice(String product) { - List> priceFutures = findPriceStream(product) + public List findPricesFuture(String product) { + List> priceFutures = findPricesStream(product) .collect(Collectors.>toList()); return priceFutures.stream() @@ -72,16 +51,16 @@ public List findPrice(String product) { .collect(Collectors.toList()); } - public Stream> findPriceStream(String product) { + public Stream> 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 index 19d70ac7..1f4f5612 100644 --- 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> s) { @@ -23,4 +20,5 @@ private static void execute(String msg, Supplier> 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 index 994ad182..e0c0b072 100644 --- 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 index e1ee1fc3..4aa88ec7 100644 --- 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 index 8b4c00fc..f0a0f5f4 100644 --- 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 index df7b2732..ff11ee61 100644 --- 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,11 +113,11 @@ 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); } @@ -113,10 +125,10 @@ private static void useTemporalAdjuster() { 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 index 7fa3fc89..61c52fb5 100644 --- 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> subs = subsets(Arrays.asList(1, 4, 9)); - subs.forEach(System.out::println); - } - public static List> subsets(List l) { if (l.isEmpty()) { List> ans = new ArrayList<>(); @@ -30,9 +26,11 @@ public static List> subsets(List l) { } public static List> insertAll(Integer first, List> lists) { - List> result = new ArrayList<>(); for (List l : lists) { - List copyList = new ArrayList<>(l); + List> result = new ArrayList<>(); + for (List l : lists) { + List 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 index f9e3b1a7..4fb99db0 100644 --- 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 Function compose(Function g, Function f) { + static Function compose(Function g, Function f) { return x -> g.apply(f.apply(x)); } - static Function repeat(int n, Function f) { - return n==0?x->x : compose(f, (Function) repeat(n-1, f)); + static Function repeat(int n, Function 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 index 4f366f42..d1fc3551 100644 --- 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; + } } diff --git a/src/main/java/lambdasinaction/chap13/LazyLists.java b/src/main/java/lambdasinaction/chap13/LazyLists.java index 72fac731..43d73173 100644 --- a/src/main/java/lambdasinaction/chap13/LazyLists.java +++ b/src/main/java/lambdasinaction/chap13/LazyLists.java @@ -3,13 +3,11 @@ import java.util.function.Supplier; import java.util.function.Predicate; - public class LazyLists { - public static void main(String[] args) { - MyList l = - new MyLinkedList<>(5, new MyLinkedList<>(10, new Empty())); + MyList l = new MyLinkedList<>(5, new MyLinkedList<>(10, + new Empty())); System.out.println(l.head()); @@ -19,69 +17,79 @@ public static void main(String[] args) { int four = numbers.tail().tail().head(); System.out.println(two + " " + three + " " + four); - numbers = from(2); int prime_two = primes(numbers).head(); int prime_three = primes(numbers).tail().head(); int prime_five = primes(numbers).tail().tail().head(); System.out.println(prime_two + " " + prime_three + " " + prime_five); - // this will run until a stackoverflow occur because Java does not support tail call elimination - //printAll(primes(from(2))); + // this will run until a stackoverflow occur because Java does not + // support tail call elimination + // printAll(primes(from(2))); } interface MyList { T head(); + MyList tail(); + default boolean isEmpty() { return true; } + MyList filter(Predicate p); } static class MyLinkedList implements MyList { final T head; final MyList tail; + public MyLinkedList(T head, MyList tail) { this.head = head; this.tail = tail; } + public T head() { return head; } + public MyList tail() { return tail; } + public boolean isEmpty() { return false; } public MyList filter(Predicate p) { - return isEmpty() ? - this: p.test(head()) ? - new MyLinkedList<>(head(), tail().filter(p)) : tail().filter(p); + return isEmpty() ? this : p.test(head()) ? new MyLinkedList<>( + head(), tail().filter(p)) : tail().filter(p); } } + static class Empty implements MyList { public T head() { throw new UnsupportedOperationException(); } + public MyList tail() { throw new UnsupportedOperationException(); } - public MyList filter(Predicate p){ + + public MyList filter(Predicate p) { return this; } } - - static class LazyList implements MyList{ + static class LazyList implements MyList { final T head; final Supplier> tail; + public LazyList(T head, Supplier> tail) { this.head = head; - this.tail = tail; + this.tail = tail; } + public T head() { return head; } @@ -89,31 +97,29 @@ public T head() { public MyList tail() { return tail.get(); } + public boolean isEmpty() { return false; } public MyList filter(Predicate p) { - return isEmpty() ? - this: p.test(head()) ? - new LazyList<>(head(), () -> tail().filter(p)) : tail().filter(p); + return isEmpty() ? this : p.test(head()) ? new LazyList<>(head(), + () -> tail().filter(p)) : tail().filter(p); } } public static LazyList from(int n) { - return new LazyList(n, () -> from(n+1)); + return new LazyList(n, () -> from(n + 1)); } - - public static MyList primes(MyList numbers) { - return new LazyList<>( numbers.head(), - () -> primes(numbers.tail().filter(n -> n % numbers.head() != 0))); + return new LazyList<>(numbers.head(), () -> primes(numbers.tail() + .filter(n -> n % numbers.head() != 0))); } - static void printAll(MyList numbers){ - if (numbers.isEmpty()){ + static void printAll(MyList numbers) { + if (numbers.isEmpty()) { return; } System.out.println(numbers.head()); @@ -121,5 +127,3 @@ static void printAll(MyList numbers){ } } - - diff --git a/src/main/java/lambdasinaction/chap13/PatternMatching.java b/src/main/java/lambdasinaction/chap13/PatternMatching.java index 3de10b0c..cf9af017 100644 --- a/src/main/java/lambdasinaction/chap13/PatternMatching.java +++ b/src/main/java/lambdasinaction/chap13/PatternMatching.java @@ -1,36 +1,137 @@ package lambdasinaction.chap13; - import java.util.function.Function; import java.util.function.Supplier; public class PatternMatching { + public static void main(String[] args) { + simplify(); + + Expr e = new BinOp("+", new Number(5), new BinOp("*", new Number(3), new Number(4))); + Integer result = evaluate(e); + System.out.println(e + " = " + result); + } + + private static void simplify() { + TriFunction binopcase = + (opname, left, right) -> { + if ("+".equals(opname)) { + if (left instanceof Number && ((Number) left).val == 0) { + return right; + } + if (right instanceof Number && ((Number) right).val == 0) { + return left; + } + } + if ("*".equals(opname)) { + if (left instanceof Number && ((Number) left).val == 1) { + return right; + } + if (right instanceof Number && ((Number) right).val == 1) { + return left; + } + } + return new BinOp(opname, left, right); + }; + Function numcase = val -> new Number(val); + Supplier defaultcase = () -> new Number(0); + + Expr e = new BinOp("+", new Number(5), new Number(0)); + Expr match = patternMatchExpr(e, binopcase, numcase, defaultcase); + if (match instanceof Number) { + System.out.println("Number: " + match); + } else if (match instanceof BinOp) { + System.out.println("BinOp: " + match); + } + } + + private static Integer evaluate(Expr e) { + Function numcase = val -> val; + Supplier defaultcase = () -> 0; + TriFunction binopcase = + (opname, left, right) -> { + if ("+".equals(opname)) { + if (left instanceof Number && right instanceof Number) { + return ((Number) left).val + ((Number) right).val; + } + if (right instanceof Number && left instanceof BinOp) { + return ((Number) right).val + evaluate((BinOp) left); + } + if (left instanceof Number && right instanceof BinOp) { + return ((Number) left).val + evaluate((BinOp) right); + } + if (left instanceof BinOp && right instanceof BinOp) { + return evaluate((BinOp) left) + evaluate((BinOp) right); + } + } + if ("*".equals(opname)) { + if (left instanceof Number && right instanceof Number) { + return ((Number) left).val * ((Number) right).val; + } + if (right instanceof Number && left instanceof BinOp) { + return ((Number) right).val * evaluate((BinOp) left); + } + if (left instanceof Number && right instanceof BinOp) { + return ((Number) left).val * evaluate((BinOp) right); + } + if (left instanceof BinOp && right instanceof BinOp) { + return evaluate((BinOp) left) * evaluate((BinOp) right); + } + } + return defaultcase.get(); + }; + + return patternMatchExpr(e, binopcase, numcase, defaultcase); + } + + static class Expr { + } - static class Expr { } - static class Number extends Expr { int val; } - static class BinOp extends Expr { String opname; Expr left, right; } + static class Number extends Expr { + int val; + public Number(int val) { + this.val = val; + } + @Override + public String toString() { + return "" + val; + } + } + static class BinOp extends Expr { + String opname; + Expr left, right; + public BinOp(String opname, Expr left, Expr right) { + this.opname = opname; + this.left = left; + this.right = right; + } + + @Override + public String toString() { + return "(" + left + " " + opname + " " + right + ")"; + } + } static T MyIf(boolean b, Supplier truecase, Supplier falsecase) { return b ? truecase.get() : falsecase.get(); } - static interface TriFunction{ + static interface TriFunction { R apply(S s, T t, U u); } - static T PatternMatchExpr( Expr e, - TriFunction binopcase, Function numcase, - Supplier defaultcase) { - if(e instanceof BinOp){ - return binopcase.apply(((BinOp)e).opname, ((BinOp)e).left, ((BinOp)e).right); - } - else if(e instanceof Number){ - return numcase.apply(((Number)e).val); - } - else{ + static T patternMatchExpr(Expr e, + TriFunction binopcase, + Function numcase, Supplier defaultcase) { + + if (e instanceof BinOp) { + return binopcase.apply(((BinOp) e).opname, ((BinOp) e).left, ((BinOp) e).right); + } else if (e instanceof Number) { + return numcase.apply(((Number) e).val); + } else { return defaultcase.get(); } } diff --git a/src/main/java/lambdasinaction/chap4/Mapping.java b/src/main/java/lambdasinaction/chap4/Mapping.java index 7752d20d..9adf3c99 100644 --- a/src/main/java/lambdasinaction/chap4/Mapping.java +++ b/src/main/java/lambdasinaction/chap4/Mapping.java @@ -32,8 +32,8 @@ public static void main(String...args){ List numbers2 = Arrays.asList(6,7,8); List pairs = numbers1.stream() - .flatMap(i -> numbers2.stream() - .map(j -> new int[]{i, j}) + .flatMap((Integer i) -> numbers2.stream() + .map((Integer j) -> new int[]{i, j}) ) .filter(pair -> (pair[0] + pair[1]) % 3 == 0) .collect(toList()); diff --git a/src/main/java/lambdasinaction/chap5/Grouping.java b/src/main/java/lambdasinaction/chap5/Grouping.java index 5dc1b7ce..9065d02f 100644 --- a/src/main/java/lambdasinaction/chap5/Grouping.java +++ b/src/main/java/lambdasinaction/chap5/Grouping.java @@ -38,7 +38,7 @@ private static Map> groupDishesByCaloricLevel() { private static Map>> groupDishedByTypeAndCaloricLevel() { return menu.stream().collect( groupingBy(Dish::getType, - groupingBy(dish -> { + groupingBy((Dish dish) -> { if (dish.getCalories() <= 400) return CaloricLevel.DIET; else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL; else return CaloricLevel.FAT; @@ -54,7 +54,7 @@ private static Map countDishesInGroups() { private static Map> mostCaloricDishesByType() { return menu.stream().collect( groupingBy(Dish::getType, - reducing((d1, d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2))); + reducing((Dish d1, Dish d2) -> d1.getCalories() > d2.getCalories() ? d1 : d2))); } private static Map mostCaloricDishesByTypeWithoutOprionals() { From 8fe642fb13e34e18a91b5d0d3827f08136029a53 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jean-Fran=C3=A7ois=20Morin?= Date: Sat, 28 Jun 2014 22:09:29 -0400 Subject: [PATCH 03/12] Technical proofing by Jean-Francois Morin --- .../java/lambdasinaction/appa/Author.java | 13 ++ .../java/lambdasinaction/appa/Authors.java | 11 ++ src/main/java/lambdasinaction/appa/Book.java | 17 ++ .../{chap6 => appc}/StreamForker.java | 2 +- .../{chap6 => appc}/StreamForkerExample.java | 2 +- .../java/lambdasinaction/appd/InnerClass.java | 12 ++ .../java/lambdasinaction/appd/Lambda.java | 7 + .../chap10/v1/BestPriceFinder.java | 163 ++++++++++++++++++ .../chap10/v1/BestPriceFinderMain.java | 25 +++ .../java/lambdasinaction/chap10/v1/Shop.java | 41 +++++ .../lambdasinaction/chap10/v1/ShopMain.java | 32 ++++ .../chap13/PersistentDataStructures.java | 32 ---- 12 files changed, 323 insertions(+), 34 deletions(-) create mode 100644 src/main/java/lambdasinaction/appa/Author.java create mode 100644 src/main/java/lambdasinaction/appa/Authors.java create mode 100644 src/main/java/lambdasinaction/appa/Book.java rename src/main/java/lambdasinaction/{chap6 => appc}/StreamForker.java (99%) rename src/main/java/lambdasinaction/{chap6 => appc}/StreamForkerExample.java (97%) create mode 100644 src/main/java/lambdasinaction/appd/InnerClass.java create mode 100644 src/main/java/lambdasinaction/appd/Lambda.java create mode 100644 src/main/java/lambdasinaction/chap10/v1/BestPriceFinder.java create mode 100644 src/main/java/lambdasinaction/chap10/v1/BestPriceFinderMain.java create mode 100644 src/main/java/lambdasinaction/chap10/v1/Shop.java create mode 100644 src/main/java/lambdasinaction/chap10/v1/ShopMain.java delete mode 100644 src/main/java/lambdasinaction/chap13/PersistentDataStructures.java diff --git a/src/main/java/lambdasinaction/appa/Author.java b/src/main/java/lambdasinaction/appa/Author.java new file mode 100644 index 00000000..a99235b9 --- /dev/null +++ b/src/main/java/lambdasinaction/appa/Author.java @@ -0,0 +1,13 @@ +package lambdasinaction.appa; + +import java.lang.annotation.Repeatable; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Repeatable(Authors.class) +@Retention(RetentionPolicy.RUNTIME) +public @interface Author { + + String name(); + +} diff --git a/src/main/java/lambdasinaction/appa/Authors.java b/src/main/java/lambdasinaction/appa/Authors.java new file mode 100644 index 00000000..f015d102 --- /dev/null +++ b/src/main/java/lambdasinaction/appa/Authors.java @@ -0,0 +1,11 @@ +package lambdasinaction.appa; + +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; + +@Retention(RetentionPolicy.RUNTIME) +public @interface Authors { + + Author[] value(); + +} diff --git a/src/main/java/lambdasinaction/appa/Book.java b/src/main/java/lambdasinaction/appa/Book.java new file mode 100644 index 00000000..beefd807 --- /dev/null +++ b/src/main/java/lambdasinaction/appa/Book.java @@ -0,0 +1,17 @@ +package lambdasinaction.appa; + +import java.util.Arrays; + +@Author(name = "Raoul") +@Author(name = "Mario") +@Author(name = "Alan") +public class Book { + + public static void main(String[] args) { + Author[] authors = Book.class.getAnnotationsByType(Author.class); + Arrays.asList(authors).stream().forEach(a -> { + System.out.println(a.name()); + }); + } + +} diff --git a/src/main/java/lambdasinaction/chap6/StreamForker.java b/src/main/java/lambdasinaction/appc/StreamForker.java similarity index 99% rename from src/main/java/lambdasinaction/chap6/StreamForker.java rename to src/main/java/lambdasinaction/appc/StreamForker.java index f184e251..d8ed124c 100644 --- a/src/main/java/lambdasinaction/chap6/StreamForker.java +++ b/src/main/java/lambdasinaction/appc/StreamForker.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap6; +package lambdasinaction.appc; import java.util.*; import java.util.concurrent.*; diff --git a/src/main/java/lambdasinaction/chap6/StreamForkerExample.java b/src/main/java/lambdasinaction/appc/StreamForkerExample.java similarity index 97% rename from src/main/java/lambdasinaction/chap6/StreamForkerExample.java rename to src/main/java/lambdasinaction/appc/StreamForkerExample.java index 551f816c..fe2dacd5 100644 --- a/src/main/java/lambdasinaction/chap6/StreamForkerExample.java +++ b/src/main/java/lambdasinaction/appc/StreamForkerExample.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap6; +package lambdasinaction.appc; import lambdasinaction.chap5.*; diff --git a/src/main/java/lambdasinaction/appd/InnerClass.java b/src/main/java/lambdasinaction/appd/InnerClass.java new file mode 100644 index 00000000..404b7b08 --- /dev/null +++ b/src/main/java/lambdasinaction/appd/InnerClass.java @@ -0,0 +1,12 @@ +package lambdasinaction.appd; + +import java.util.function.Function; + +public class InnerClass { + Function f = new Function() { + @Override + public String apply(Object obj) { + return obj.toString(); + } + }; +} diff --git a/src/main/java/lambdasinaction/appd/Lambda.java b/src/main/java/lambdasinaction/appd/Lambda.java new file mode 100644 index 00000000..e8381505 --- /dev/null +++ b/src/main/java/lambdasinaction/appd/Lambda.java @@ -0,0 +1,7 @@ +package lambdasinaction.appd; + +import java.util.function.Function; + +public class Lambda { + Function f = obj -> obj.toString(); +} diff --git a/src/main/java/lambdasinaction/chap10/v1/BestPriceFinder.java b/src/main/java/lambdasinaction/chap10/v1/BestPriceFinder.java new file mode 100644 index 00000000..42022883 --- /dev/null +++ b/src/main/java/lambdasinaction/chap10/v1/BestPriceFinder.java @@ -0,0 +1,163 @@ +package lambdasinaction.chap10.v1; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.Callable; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Executor; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.Future; +import java.util.concurrent.ThreadFactory; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import lambdasinaction.chap10.ExchangeService; +import lambdasinaction.chap10.ExchangeService.Money; + +public class BestPriceFinder { + + private final List shops = Arrays.asList(new Shop("BestPrice"), + new Shop("LetsSaveBig"), + new Shop("MyFavoriteShop"), + new Shop("BuyItAll")/*, + new Shop("ShopEasy")*/); + + private final Executor executor = Executors.newFixedThreadPool(shops.size(), new ThreadFactory() { + @Override + public Thread newThread(Runnable r) { + Thread t = new Thread(r); + t.setDaemon(true); + return t; + } + }); + + public List findPricesSequential(String product) { + return shops.stream() + .map(shop -> shop.getName() + " price is " + shop.getPrice(product)) + .collect(Collectors.toList()); + } + + public List findPricesParallel(String product) { + return shops.parallelStream() + .map(shop -> shop.getName() + " price is " + shop.getPrice(product)) + .collect(Collectors.toList()); + } + + public List findPricesFuture(String product) { + List> priceFutures = + shops.stream() + .map(shop -> CompletableFuture.supplyAsync(() -> shop.getName() + " price is " + + shop.getPrice(product), executor)) + .collect(Collectors.toList()); + + List prices = priceFutures.stream() + .map(CompletableFuture::join) + .collect(Collectors.toList()); + return prices; + } + + public List findPricesInUSD(String product) { + List> priceFutures = new ArrayList<>(); + for (Shop shop : shops) { + // Start of Listing 10.20. + // Only the type of futurePriceInUSD has been changed to + // CompletableFuture so that it is compatible with the + // CompletableFuture::join operation below. + CompletableFuture futurePriceInUSD = + CompletableFuture.supplyAsync(() -> shop.getPrice(product)) + .thenCombine( + CompletableFuture.supplyAsync( + () -> ExchangeService.getRate(Money.EUR, Money.USD)), + (price, rate) -> price * rate + ); + priceFutures.add(futurePriceInUSD); + } + // Drawback: The shop is not accessible anymore outside the loop, + // so the getName() call below has been commented out. + List prices = priceFutures + .stream() + .map(CompletableFuture::join) + .map(price -> /*shop.getName() +*/ " price is " + price) + .collect(Collectors.toList()); + return prices; + } + + public List findPricesInUSDJava7(String product) { + ExecutorService executor = Executors.newCachedThreadPool(); + List> priceFutures = new ArrayList<>(); + for (Shop shop : shops) { + final Future futureRate = executor.submit(new Callable() { + public Double call() { + return ExchangeService.getRate(Money.EUR, Money.USD); + } + }); + Future futurePriceInUSD = executor.submit(new Callable() { + public Double call() { + try { + double priceInEUR = shop.getPrice(product); + return priceInEUR * futureRate.get(); + } catch (InterruptedException | ExecutionException e) { + throw new RuntimeException(e.getMessage(), e); + } + } + }); + priceFutures.add(futurePriceInUSD); + } + List prices = new ArrayList<>(); + for (Future priceFuture : priceFutures) { + try { + prices.add(/*shop.getName() +*/ " price is " + priceFuture.get()); + } + catch (ExecutionException | InterruptedException e) { + e.printStackTrace(); + } + } + return prices; + } + + public List findPricesInUSD2(String product) { + List> priceFutures = new ArrayList<>(); + for (Shop shop : shops) { + // Here, an extra operation has been added so that the shop name + // is retrieved within the loop. As a result, we now deal with + // CompletableFuture instances. + CompletableFuture futurePriceInUSD = + CompletableFuture.supplyAsync(() -> shop.getPrice(product)) + .thenCombine( + CompletableFuture.supplyAsync( + () -> ExchangeService.getRate(Money.EUR, Money.USD)), + (price, rate) -> price * rate + ).thenApply(price -> shop.getName() + " price is " + price); + priceFutures.add(futurePriceInUSD); + } + List prices = priceFutures + .stream() + .map(CompletableFuture::join) + .collect(Collectors.toList()); + return prices; + } + + public List findPricesInUSD3(String product) { + // Here, the for loop has been replaced by a mapping function... + Stream> priceFuturesStream = shops + .stream() + .map(shop -> CompletableFuture + .supplyAsync(() -> shop.getPrice(product)) + .thenCombine( + CompletableFuture.supplyAsync(() -> ExchangeService.getRate(Money.EUR, Money.USD)), + (price, rate) -> price * rate) + .thenApply(price -> shop.getName() + " price is " + price)); + // However, we should gather the CompletableFutures into a List so that the asynchronous + // operations are triggered before being "joined." + List> priceFutures = priceFuturesStream.collect(Collectors.toList()); + List prices = priceFutures + .stream() + .map(CompletableFuture::join) + .collect(Collectors.toList()); + return prices; + } + +} diff --git a/src/main/java/lambdasinaction/chap10/v1/BestPriceFinderMain.java b/src/main/java/lambdasinaction/chap10/v1/BestPriceFinderMain.java new file mode 100644 index 00000000..c1c0f80a --- /dev/null +++ b/src/main/java/lambdasinaction/chap10/v1/BestPriceFinderMain.java @@ -0,0 +1,25 @@ +package lambdasinaction.chap10.v1; + +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.findPricesSequential("myPhone27S")); + execute("parallel", () -> bestPriceFinder.findPricesParallel("myPhone27S")); + execute("composed CompletableFuture", () -> bestPriceFinder.findPricesFuture("myPhone27S")); + execute("combined USD CompletableFuture", () -> bestPriceFinder.findPricesInUSD("myPhone27S")); + execute("combined USD CompletableFuture v2", () -> bestPriceFinder.findPricesInUSD2("myPhone27S")); + execute("combined USD CompletableFuture v3", () -> bestPriceFinder.findPricesInUSD3("myPhone27S")); + } + + private static void execute(String msg, Supplier> s) { + long start = System.nanoTime(); + System.out.println(s.get()); + long duration = (System.nanoTime() - start) / 1_000_000; + System.out.println(msg + " done in " + duration + " msecs"); + } +} diff --git a/src/main/java/lambdasinaction/chap10/v1/Shop.java b/src/main/java/lambdasinaction/chap10/v1/Shop.java new file mode 100644 index 00000000..9a4350d3 --- /dev/null +++ b/src/main/java/lambdasinaction/chap10/v1/Shop.java @@ -0,0 +1,41 @@ +package lambdasinaction.chap10.v1; + +import static lambdasinaction.chap10.Util.delay; + +import java.util.Random; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.Future; + +public class Shop { + + private final String name; + private final Random random; + + public Shop(String name) { + this.name = name; + random = new Random(name.charAt(0) * name.charAt(1) * name.charAt(2)); + } + + public double getPrice(String product) { + return calculatePrice(product); + } + + private double calculatePrice(String product) { + delay(); + return random.nextDouble() * product.charAt(0) + product.charAt(1); + } + + public Future getPriceAsync(String product) { + CompletableFuture futurePrice = new CompletableFuture<>(); + new Thread( () -> { + double price = calculatePrice(product); + futurePrice.complete(price); + }).start(); + return futurePrice; + } + + public String getName() { + return name; + } + +} diff --git a/src/main/java/lambdasinaction/chap10/v1/ShopMain.java b/src/main/java/lambdasinaction/chap10/v1/ShopMain.java new file mode 100644 index 00000000..b972713f --- /dev/null +++ b/src/main/java/lambdasinaction/chap10/v1/ShopMain.java @@ -0,0 +1,32 @@ +package lambdasinaction.chap10.v1; + +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; + +public class ShopMain { + + public static void main(String[] args) { + Shop shop = new Shop("BestShop"); + long start = System.nanoTime(); + Future futurePrice = shop.getPriceAsync("my favorite product"); + long invocationTime = ((System.nanoTime() - start) / 1_000_000); + System.out.println("Invocation returned after " + invocationTime + + " msecs"); + // Do some more tasks, like querying other shops + doSomethingElse(); + // while the price of the product is being calculated + try { + double price = futurePrice.get(); + System.out.printf("Price is %.2f%n", price); + } catch (ExecutionException | InterruptedException e) { + throw new RuntimeException(e); + } + long retrievalTime = ((System.nanoTime() - start) / 1_000_000); + System.out.println("Price returned after " + retrievalTime + " msecs"); + } + + private static void doSomethingElse() { + System.out.println("Doing something else..."); + } + +} diff --git a/src/main/java/lambdasinaction/chap13/PersistentDataStructures.java b/src/main/java/lambdasinaction/chap13/PersistentDataStructures.java deleted file mode 100644 index a2650b14..00000000 --- a/src/main/java/lambdasinaction/chap13/PersistentDataStructures.java +++ /dev/null @@ -1,32 +0,0 @@ -package lambdasinaction.chap13; - - -public class PersistentDataStructures { - - - static class TrainJourney { - public int price; - public TrainJourney onward; - public TrainJourney(int p, TrainJourney t) { - price = p; - onward = t; - } - } - - static TrainJourney link(TrainJourney a, TrainJourney b) { - if (a==null){ - return b; - } - TrainJourney t = a; - while(t.onward != null){ - t = t.onward; - } - t.onward = b; - return a; - } - - static TrainJourney append(TrainJourney a, TrainJourney b) - { - return a==null ? b : new TrainJourney(a.price, append(a.onward, b)); - } -} From b734604412a7ec3064baf8a749f003f6e38af8a0 Mon Sep 17 00:00:00 2001 From: Mario Fusco Date: Tue, 15 Jul 2014 20:37:31 +0200 Subject: [PATCH 04/12] refactor package names --- .../appc/StreamForkerExample.java | 4 +- .../{chap9 => chap10}/Car.java | 2 +- .../{chap9 => chap10}/Insurance.java | 2 +- .../OperationsWithOptional.java | 2 +- .../{chap9 => chap10}/OptionalMain.java | 2 +- .../{chap9 => chap10}/Person.java | 2 +- .../ReadPositiveIntParam.java | 2 +- .../{chap10 => chap11}/AsyncShop.java | 6 +-- .../{chap10 => chap11}/AsyncShopClient.java | 2 +- .../{chap10 => chap11}/BestPriceFinder.java | 2 +- .../BestPriceFinderMain.java | 2 +- .../{chap10 => chap11}/Discount.java | 6 +-- .../{chap10 => chap11}/ExchangeService.java | 4 +- .../{chap10 => chap11}/Quote.java | 2 +- .../{chap10 => chap11}/Shop.java | 6 +-- .../{chap10 => chap11}/Util.java | 2 +- .../v1/BestPriceFinder.java | 6 +-- .../v1/BestPriceFinderMain.java | 2 +- .../{chap10 => chap11}/v1/Shop.java | 4 +- .../{chap10 => chap11}/v1/ShopMain.java | 2 +- .../{chap11 => chap12}/DateTimeExamples.java | 2 +- .../{chap12 => chap13}/Recursion.java | 2 +- .../{chap12 => chap13}/SubsetsMain.java | 2 +- .../{chap13 => chap14}/Combinators.java | 2 +- .../{chap13 => chap14}/Currying.java | 2 +- .../{chap13 => chap14}/LazyLists.java | 2 +- .../{chap13 => chap14}/PatternMatching.java | 2 +- .../PersistentTrainJourney.java | 2 +- .../{chap13 => chap14}/PersistentTree.java | 2 +- .../java/lambdasinaction/chap4/Reducing.java | 29 ------------- .../{chap4 => chap5}/BuildingStreams.java | 5 +-- .../{chap4 => chap5}/Filtering.java | 4 +- .../{chap4 => chap5}/Finding.java | 4 +- .../{chap4 => chap5}/Laziness.java | 2 +- .../{chap4 => chap5}/Mapping.java | 4 +- .../{chap4 => chap5}/NumericStreams.java | 4 +- .../{chap4 => chap5}/PuttingIntoPractice.java | 6 ++- .../java/lambdasinaction/chap5/Reducing.java | 43 +++++++++---------- .../{chap4 => chap5}/Trader.java | 2 +- .../{chap4 => chap5}/Transaction.java | 3 +- .../{chap5 => chap6}/CollectorHarness.java | 4 +- .../{chap5 => chap6}/Dish.java | 2 +- .../{chap5 => chap6}/Grouping.java | 6 +-- .../GroupingTransactions.java | 2 +- .../PartitionPrimeNumbers.java | 3 +- .../{chap5 => chap6}/Partitioning.java | 6 +-- .../java/lambdasinaction/chap6/Reducing.java | 30 +++++++++++++ .../{chap5 => chap6}/Summarizing.java | 5 +-- .../{chap5 => chap6}/ToListCollector.java | 2 +- .../ForkJoinSumCalculator.java | 5 +-- .../{chap6 => chap7}/ParallelStreams.java | 2 +- .../ParallelStreamsHarness.java | 2 +- .../{chap6 => chap7}/WordCount.java | 2 +- .../ChainOfResponsibilityMain.java | 2 +- .../{chap7 => chap8}/Debugging.java | 2 +- .../{chap7 => chap8}/FactoryMain.java | 2 +- .../{chap7 => chap8}/ObserverMain.java | 4 +- .../{chap7 => chap8}/OnlineBanking.java | 2 +- .../{chap7 => chap8}/OnlineBankingLambda.java | 2 +- .../{chap7 => chap8}/Peek.java | 2 +- .../{chap7 => chap8}/StrategyMain.java | 2 +- .../{chap8 => chap9}/Ambiguous.java | 2 +- .../{chap8 => chap9}/Diamond.java | 2 +- .../{chap8 => chap9}/Drawable.java | 2 +- .../{chap8 => chap9}/Ellipse.java | 2 +- .../{chap8 => chap9}/Game.java | 2 +- .../{chap8 => chap9}/Intro.java | 2 +- .../{chap8 => chap9}/Letter.java | 2 +- .../{chap8 => chap9}/MostSpecific.java | 2 +- .../lambdasinaction/{chap8 => chap9}/README | 0 .../{chap8 => chap9}/Resizable.java | 2 +- .../{chap8 => chap9}/Square.java | 2 +- .../{chap8 => chap9}/Triangle.java | 2 +- .../{chap8 => chap9}/Utils.java | 2 +- .../lambdasinaction/{chap4 => chap5}/data.txt | 0 75 files changed, 148 insertions(+), 151 deletions(-) rename src/main/java/lambdasinaction/{chap9 => chap10}/Car.java (84%) rename src/main/java/lambdasinaction/{chap9 => chap10}/Insurance.java (77%) rename src/main/java/lambdasinaction/{chap9 => chap10}/OperationsWithOptional.java (93%) rename src/main/java/lambdasinaction/{chap9 => chap10}/OptionalMain.java (90%) rename src/main/java/lambdasinaction/{chap9 => chap10}/Person.java (81%) rename src/main/java/lambdasinaction/{chap9 => chap10}/ReadPositiveIntParam.java (98%) rename src/main/java/lambdasinaction/{chap10 => chap11}/AsyncShop.java (89%) rename src/main/java/lambdasinaction/{chap10 => chap11}/AsyncShopClient.java (95%) rename src/main/java/lambdasinaction/{chap10 => chap11}/BestPriceFinder.java (98%) rename src/main/java/lambdasinaction/{chap10 => chap11}/BestPriceFinderMain.java (96%) rename src/main/java/lambdasinaction/{chap10 => chap11}/Discount.java (81%) rename src/main/java/lambdasinaction/{chap10 => chap11}/ExchangeService.java (86%) rename src/main/java/lambdasinaction/{chap10 => chap11}/Quote.java (96%) rename src/main/java/lambdasinaction/{chap10 => chap11}/Shop.java (84%) rename src/main/java/lambdasinaction/{chap10 => chap11}/Util.java (97%) rename src/main/java/lambdasinaction/{chap10 => chap11}/v1/BestPriceFinder.java (98%) rename src/main/java/lambdasinaction/{chap10 => chap11}/v1/BestPriceFinderMain.java (96%) rename src/main/java/lambdasinaction/{chap10 => chap11}/v1/Shop.java (92%) rename src/main/java/lambdasinaction/{chap10 => chap11}/v1/ShopMain.java (96%) rename src/main/java/lambdasinaction/{chap11 => chap12}/DateTimeExamples.java (99%) rename src/main/java/lambdasinaction/{chap12 => chap13}/Recursion.java (96%) rename src/main/java/lambdasinaction/{chap12 => chap13}/SubsetsMain.java (97%) rename src/main/java/lambdasinaction/{chap13 => chap14}/Combinators.java (93%) rename src/main/java/lambdasinaction/{chap13 => chap14}/Currying.java (96%) rename src/main/java/lambdasinaction/{chap13 => chap14}/LazyLists.java (99%) rename src/main/java/lambdasinaction/{chap13 => chap14}/PatternMatching.java (99%) rename src/main/java/lambdasinaction/{chap13 => chap14}/PersistentTrainJourney.java (98%) rename src/main/java/lambdasinaction/{chap13 => chap14}/PersistentTree.java (98%) delete mode 100644 src/main/java/lambdasinaction/chap4/Reducing.java rename src/main/java/lambdasinaction/{chap4 => chap5}/BuildingStreams.java (95%) rename src/main/java/lambdasinaction/{chap4 => chap5}/Filtering.java (94%) rename src/main/java/lambdasinaction/{chap4 => chap5}/Finding.java (94%) rename src/main/java/lambdasinaction/{chap4 => chap5}/Laziness.java (96%) rename src/main/java/lambdasinaction/{chap4 => chap5}/Mapping.java (95%) rename src/main/java/lambdasinaction/{chap4 => chap5}/NumericStreams.java (96%) rename src/main/java/lambdasinaction/{chap4 => chap5}/PuttingIntoPractice.java (98%) rename src/main/java/lambdasinaction/{chap4 => chap5}/Trader.java (92%) rename src/main/java/lambdasinaction/{chap4 => chap5}/Transaction.java (94%) rename src/main/java/lambdasinaction/{chap5 => chap6}/CollectorHarness.java (89%) rename src/main/java/lambdasinaction/{chap5 => chap6}/Dish.java (97%) rename src/main/java/lambdasinaction/{chap5 => chap6}/Grouping.java (96%) rename src/main/java/lambdasinaction/{chap5 => chap6}/GroupingTransactions.java (99%) rename src/main/java/lambdasinaction/{chap5 => chap6}/PartitionPrimeNumbers.java (98%) rename src/main/java/lambdasinaction/{chap5 => chap6}/Partitioning.java (89%) create mode 100644 src/main/java/lambdasinaction/chap6/Reducing.java rename src/main/java/lambdasinaction/{chap5 => chap6}/Summarizing.java (95%) rename src/main/java/lambdasinaction/{chap5 => chap6}/ToListCollector.java (96%) rename src/main/java/lambdasinaction/{chap6 => chap7}/ForkJoinSumCalculator.java (91%) rename src/main/java/lambdasinaction/{chap6 => chap7}/ParallelStreams.java (97%) rename src/main/java/lambdasinaction/{chap6 => chap7}/ParallelStreamsHarness.java (98%) rename src/main/java/lambdasinaction/{chap6 => chap7}/WordCount.java (99%) rename src/main/java/lambdasinaction/{chap7 => chap8}/ChainOfResponsibilityMain.java (98%) rename src/main/java/lambdasinaction/{chap7 => chap8}/Debugging.java (94%) rename src/main/java/lambdasinaction/{chap7 => chap8}/FactoryMain.java (97%) rename src/main/java/lambdasinaction/{chap7 => chap8}/ObserverMain.java (96%) rename src/main/java/lambdasinaction/{chap7 => chap8}/OnlineBanking.java (93%) rename src/main/java/lambdasinaction/{chap7 => chap8}/OnlineBankingLambda.java (95%) rename src/main/java/lambdasinaction/{chap7 => chap8}/Peek.java (94%) rename src/main/java/lambdasinaction/{chap7 => chap8}/StrategyMain.java (97%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Ambiguous.java (93%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Diamond.java (91%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Drawable.java (77%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Ellipse.java (93%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Game.java (90%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Intro.java (92%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Letter.java (95%) rename src/main/java/lambdasinaction/{chap8 => chap9}/MostSpecific.java (95%) rename src/main/java/lambdasinaction/{chap8 => chap9}/README (100%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Resizable.java (92%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Square.java (93%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Triangle.java (93%) rename src/main/java/lambdasinaction/{chap8 => chap9}/Utils.java (89%) rename src/main/resources/lambdasinaction/{chap4 => chap5}/data.txt (100%) diff --git a/src/main/java/lambdasinaction/appc/StreamForkerExample.java b/src/main/java/lambdasinaction/appc/StreamForkerExample.java index fe2dacd5..1d1ffdbc 100644 --- a/src/main/java/lambdasinaction/appc/StreamForkerExample.java +++ b/src/main/java/lambdasinaction/appc/StreamForkerExample.java @@ -1,9 +1,9 @@ package lambdasinaction.appc; -import lambdasinaction.chap5.*; +import lambdasinaction.chap6.*; import static java.util.stream.Collectors.*; -import static lambdasinaction.chap5.Dish.menu; +import static lambdasinaction.chap6.Dish.menu; import java.util.*; import java.util.stream.*; diff --git a/src/main/java/lambdasinaction/chap9/Car.java b/src/main/java/lambdasinaction/chap10/Car.java similarity index 84% rename from src/main/java/lambdasinaction/chap9/Car.java rename to src/main/java/lambdasinaction/chap10/Car.java index 1b0f77db..36f00727 100644 --- a/src/main/java/lambdasinaction/chap9/Car.java +++ b/src/main/java/lambdasinaction/chap10/Car.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap9; +package lambdasinaction.chap10; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap9/Insurance.java b/src/main/java/lambdasinaction/chap10/Insurance.java similarity index 77% rename from src/main/java/lambdasinaction/chap9/Insurance.java rename to src/main/java/lambdasinaction/chap10/Insurance.java index d48eb927..69409686 100644 --- a/src/main/java/lambdasinaction/chap9/Insurance.java +++ b/src/main/java/lambdasinaction/chap10/Insurance.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap9; +package lambdasinaction.chap10; public class Insurance { diff --git a/src/main/java/lambdasinaction/chap9/OperationsWithOptional.java b/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java similarity index 93% rename from src/main/java/lambdasinaction/chap9/OperationsWithOptional.java rename to src/main/java/lambdasinaction/chap10/OperationsWithOptional.java index cc5491db..de588759 100644 --- a/src/main/java/lambdasinaction/chap9/OperationsWithOptional.java +++ b/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap9; +package lambdasinaction.chap10; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap9/OptionalMain.java b/src/main/java/lambdasinaction/chap10/OptionalMain.java similarity index 90% rename from src/main/java/lambdasinaction/chap9/OptionalMain.java rename to src/main/java/lambdasinaction/chap10/OptionalMain.java index 1db2ab03..1826cb4a 100644 --- a/src/main/java/lambdasinaction/chap9/OptionalMain.java +++ b/src/main/java/lambdasinaction/chap10/OptionalMain.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap9; +package lambdasinaction.chap10; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap9/Person.java b/src/main/java/lambdasinaction/chap10/Person.java similarity index 81% rename from src/main/java/lambdasinaction/chap9/Person.java rename to src/main/java/lambdasinaction/chap10/Person.java index eb4d3726..5e84e552 100644 --- a/src/main/java/lambdasinaction/chap9/Person.java +++ b/src/main/java/lambdasinaction/chap10/Person.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap9; +package lambdasinaction.chap10; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap9/ReadPositiveIntParam.java b/src/main/java/lambdasinaction/chap10/ReadPositiveIntParam.java similarity index 98% rename from src/main/java/lambdasinaction/chap9/ReadPositiveIntParam.java rename to src/main/java/lambdasinaction/chap10/ReadPositiveIntParam.java index ee2cf434..acac12b9 100644 --- a/src/main/java/lambdasinaction/chap9/ReadPositiveIntParam.java +++ b/src/main/java/lambdasinaction/chap10/ReadPositiveIntParam.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap9; +package lambdasinaction.chap10; import org.junit.*; diff --git a/src/main/java/lambdasinaction/chap10/AsyncShop.java b/src/main/java/lambdasinaction/chap11/AsyncShop.java similarity index 89% rename from src/main/java/lambdasinaction/chap10/AsyncShop.java rename to src/main/java/lambdasinaction/chap11/AsyncShop.java index 4d230e7d..9d537368 100644 --- a/src/main/java/lambdasinaction/chap10/AsyncShop.java +++ b/src/main/java/lambdasinaction/chap11/AsyncShop.java @@ -1,7 +1,7 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; -import static lambdasinaction.chap10.Util.delay; -import static lambdasinaction.chap10.Util.format; +import static lambdasinaction.chap11.Util.delay; +import static lambdasinaction.chap11.Util.format; import java.util.Random; import java.util.concurrent.CompletableFuture; diff --git a/src/main/java/lambdasinaction/chap10/AsyncShopClient.java b/src/main/java/lambdasinaction/chap11/AsyncShopClient.java similarity index 95% rename from src/main/java/lambdasinaction/chap10/AsyncShopClient.java rename to src/main/java/lambdasinaction/chap11/AsyncShopClient.java index 029e9b30..9a78f827 100644 --- a/src/main/java/lambdasinaction/chap10/AsyncShopClient.java +++ b/src/main/java/lambdasinaction/chap11/AsyncShopClient.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; import java.util.concurrent.Future; diff --git a/src/main/java/lambdasinaction/chap10/BestPriceFinder.java b/src/main/java/lambdasinaction/chap11/BestPriceFinder.java similarity index 98% rename from src/main/java/lambdasinaction/chap10/BestPriceFinder.java rename to src/main/java/lambdasinaction/chap11/BestPriceFinder.java index 25cf3870..51412e93 100644 --- a/src/main/java/lambdasinaction/chap10/BestPriceFinder.java +++ b/src/main/java/lambdasinaction/chap11/BestPriceFinder.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; import java.util.Arrays; import java.util.List; diff --git a/src/main/java/lambdasinaction/chap10/BestPriceFinderMain.java b/src/main/java/lambdasinaction/chap11/BestPriceFinderMain.java similarity index 96% rename from src/main/java/lambdasinaction/chap10/BestPriceFinderMain.java rename to src/main/java/lambdasinaction/chap11/BestPriceFinderMain.java index 1f4f5612..43ec8fba 100644 --- a/src/main/java/lambdasinaction/chap10/BestPriceFinderMain.java +++ b/src/main/java/lambdasinaction/chap11/BestPriceFinderMain.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; import java.util.List; import java.util.function.Supplier; diff --git a/src/main/java/lambdasinaction/chap10/Discount.java b/src/main/java/lambdasinaction/chap11/Discount.java similarity index 81% rename from src/main/java/lambdasinaction/chap10/Discount.java rename to src/main/java/lambdasinaction/chap11/Discount.java index e0c0b072..5624abd1 100644 --- a/src/main/java/lambdasinaction/chap10/Discount.java +++ b/src/main/java/lambdasinaction/chap11/Discount.java @@ -1,7 +1,7 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; -import static lambdasinaction.chap10.Util.delay; -import static lambdasinaction.chap10.Util.format; +import static lambdasinaction.chap11.Util.delay; +import static lambdasinaction.chap11.Util.format; public class Discount { diff --git a/src/main/java/lambdasinaction/chap10/ExchangeService.java b/src/main/java/lambdasinaction/chap11/ExchangeService.java similarity index 86% rename from src/main/java/lambdasinaction/chap10/ExchangeService.java rename to src/main/java/lambdasinaction/chap11/ExchangeService.java index 9ae1ccdb..3f98a7e3 100644 --- a/src/main/java/lambdasinaction/chap10/ExchangeService.java +++ b/src/main/java/lambdasinaction/chap11/ExchangeService.java @@ -1,6 +1,6 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; -import static lambdasinaction.chap10.Util.delay; +import static lambdasinaction.chap11.Util.delay; public class ExchangeService { diff --git a/src/main/java/lambdasinaction/chap10/Quote.java b/src/main/java/lambdasinaction/chap11/Quote.java similarity index 96% rename from src/main/java/lambdasinaction/chap10/Quote.java rename to src/main/java/lambdasinaction/chap11/Quote.java index 2bba954b..72dd81bf 100644 --- a/src/main/java/lambdasinaction/chap10/Quote.java +++ b/src/main/java/lambdasinaction/chap11/Quote.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; public class Quote { diff --git a/src/main/java/lambdasinaction/chap10/Shop.java b/src/main/java/lambdasinaction/chap11/Shop.java similarity index 84% rename from src/main/java/lambdasinaction/chap10/Shop.java rename to src/main/java/lambdasinaction/chap11/Shop.java index 4aa88ec7..bf0446fe 100644 --- a/src/main/java/lambdasinaction/chap10/Shop.java +++ b/src/main/java/lambdasinaction/chap11/Shop.java @@ -1,7 +1,7 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; -import static lambdasinaction.chap10.Util.delay; -import static lambdasinaction.chap10.Util.format; +import static lambdasinaction.chap11.Util.delay; +import static lambdasinaction.chap11.Util.format; import java.util.Random; diff --git a/src/main/java/lambdasinaction/chap10/Util.java b/src/main/java/lambdasinaction/chap11/Util.java similarity index 97% rename from src/main/java/lambdasinaction/chap10/Util.java rename to src/main/java/lambdasinaction/chap11/Util.java index f0a0f5f4..a72c4d33 100644 --- a/src/main/java/lambdasinaction/chap10/Util.java +++ b/src/main/java/lambdasinaction/chap11/Util.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap10; +package lambdasinaction.chap11; import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; diff --git a/src/main/java/lambdasinaction/chap10/v1/BestPriceFinder.java b/src/main/java/lambdasinaction/chap11/v1/BestPriceFinder.java similarity index 98% rename from src/main/java/lambdasinaction/chap10/v1/BestPriceFinder.java rename to src/main/java/lambdasinaction/chap11/v1/BestPriceFinder.java index 42022883..1bbb6030 100644 --- a/src/main/java/lambdasinaction/chap10/v1/BestPriceFinder.java +++ b/src/main/java/lambdasinaction/chap11/v1/BestPriceFinder.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap10.v1; +package lambdasinaction.chap11.v1; import java.util.ArrayList; import java.util.Arrays; @@ -14,8 +14,8 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import lambdasinaction.chap10.ExchangeService; -import lambdasinaction.chap10.ExchangeService.Money; +import lambdasinaction.chap11.ExchangeService; +import lambdasinaction.chap11.ExchangeService.Money; public class BestPriceFinder { diff --git a/src/main/java/lambdasinaction/chap10/v1/BestPriceFinderMain.java b/src/main/java/lambdasinaction/chap11/v1/BestPriceFinderMain.java similarity index 96% rename from src/main/java/lambdasinaction/chap10/v1/BestPriceFinderMain.java rename to src/main/java/lambdasinaction/chap11/v1/BestPriceFinderMain.java index c1c0f80a..5a74161a 100644 --- a/src/main/java/lambdasinaction/chap10/v1/BestPriceFinderMain.java +++ b/src/main/java/lambdasinaction/chap11/v1/BestPriceFinderMain.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap10.v1; +package lambdasinaction.chap11.v1; import java.util.List; import java.util.function.Supplier; diff --git a/src/main/java/lambdasinaction/chap10/v1/Shop.java b/src/main/java/lambdasinaction/chap11/v1/Shop.java similarity index 92% rename from src/main/java/lambdasinaction/chap10/v1/Shop.java rename to src/main/java/lambdasinaction/chap11/v1/Shop.java index 9a4350d3..cd3da975 100644 --- a/src/main/java/lambdasinaction/chap10/v1/Shop.java +++ b/src/main/java/lambdasinaction/chap11/v1/Shop.java @@ -1,6 +1,6 @@ -package lambdasinaction.chap10.v1; +package lambdasinaction.chap11.v1; -import static lambdasinaction.chap10.Util.delay; +import static lambdasinaction.chap11.Util.delay; import java.util.Random; import java.util.concurrent.CompletableFuture; diff --git a/src/main/java/lambdasinaction/chap10/v1/ShopMain.java b/src/main/java/lambdasinaction/chap11/v1/ShopMain.java similarity index 96% rename from src/main/java/lambdasinaction/chap10/v1/ShopMain.java rename to src/main/java/lambdasinaction/chap11/v1/ShopMain.java index b972713f..ea1a19c1 100644 --- a/src/main/java/lambdasinaction/chap10/v1/ShopMain.java +++ b/src/main/java/lambdasinaction/chap11/v1/ShopMain.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap10.v1; +package lambdasinaction.chap11.v1; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; diff --git a/src/main/java/lambdasinaction/chap11/DateTimeExamples.java b/src/main/java/lambdasinaction/chap12/DateTimeExamples.java similarity index 99% rename from src/main/java/lambdasinaction/chap11/DateTimeExamples.java rename to src/main/java/lambdasinaction/chap12/DateTimeExamples.java index ff11ee61..46895cc5 100644 --- a/src/main/java/lambdasinaction/chap11/DateTimeExamples.java +++ b/src/main/java/lambdasinaction/chap12/DateTimeExamples.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap11; +package lambdasinaction.chap12; import static java.time.temporal.TemporalAdjusters.lastDayOfMonth; import static java.time.temporal.TemporalAdjusters.nextOrSame; diff --git a/src/main/java/lambdasinaction/chap12/Recursion.java b/src/main/java/lambdasinaction/chap13/Recursion.java similarity index 96% rename from src/main/java/lambdasinaction/chap12/Recursion.java rename to src/main/java/lambdasinaction/chap13/Recursion.java index 223600e7..77f66d57 100644 --- a/src/main/java/lambdasinaction/chap12/Recursion.java +++ b/src/main/java/lambdasinaction/chap13/Recursion.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap12; +package lambdasinaction.chap13; import java.util.stream.LongStream; diff --git a/src/main/java/lambdasinaction/chap12/SubsetsMain.java b/src/main/java/lambdasinaction/chap13/SubsetsMain.java similarity index 97% rename from src/main/java/lambdasinaction/chap12/SubsetsMain.java rename to src/main/java/lambdasinaction/chap13/SubsetsMain.java index 61c52fb5..02b51998 100644 --- a/src/main/java/lambdasinaction/chap12/SubsetsMain.java +++ b/src/main/java/lambdasinaction/chap13/SubsetsMain.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap12; +package lambdasinaction.chap13; import java.util.ArrayList; import java.util.Arrays; diff --git a/src/main/java/lambdasinaction/chap13/Combinators.java b/src/main/java/lambdasinaction/chap14/Combinators.java similarity index 93% rename from src/main/java/lambdasinaction/chap13/Combinators.java rename to src/main/java/lambdasinaction/chap14/Combinators.java index 4fb99db0..7ae5dfd2 100644 --- a/src/main/java/lambdasinaction/chap13/Combinators.java +++ b/src/main/java/lambdasinaction/chap14/Combinators.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap13; +package lambdasinaction.chap14; import java.util.function.Function; diff --git a/src/main/java/lambdasinaction/chap13/Currying.java b/src/main/java/lambdasinaction/chap14/Currying.java similarity index 96% rename from src/main/java/lambdasinaction/chap13/Currying.java rename to src/main/java/lambdasinaction/chap14/Currying.java index d1fc3551..f17ac928 100644 --- a/src/main/java/lambdasinaction/chap13/Currying.java +++ b/src/main/java/lambdasinaction/chap14/Currying.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap13; +package lambdasinaction.chap14; import java.util.function.DoubleUnaryOperator; diff --git a/src/main/java/lambdasinaction/chap13/LazyLists.java b/src/main/java/lambdasinaction/chap14/LazyLists.java similarity index 99% rename from src/main/java/lambdasinaction/chap13/LazyLists.java rename to src/main/java/lambdasinaction/chap14/LazyLists.java index 43d73173..658e0940 100644 --- a/src/main/java/lambdasinaction/chap13/LazyLists.java +++ b/src/main/java/lambdasinaction/chap14/LazyLists.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap13; +package lambdasinaction.chap14; import java.util.function.Supplier; import java.util.function.Predicate; diff --git a/src/main/java/lambdasinaction/chap13/PatternMatching.java b/src/main/java/lambdasinaction/chap14/PatternMatching.java similarity index 99% rename from src/main/java/lambdasinaction/chap13/PatternMatching.java rename to src/main/java/lambdasinaction/chap14/PatternMatching.java index cf9af017..400593d4 100644 --- a/src/main/java/lambdasinaction/chap13/PatternMatching.java +++ b/src/main/java/lambdasinaction/chap14/PatternMatching.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap13; +package lambdasinaction.chap14; import java.util.function.Function; import java.util.function.Supplier; diff --git a/src/main/java/lambdasinaction/chap13/PersistentTrainJourney.java b/src/main/java/lambdasinaction/chap14/PersistentTrainJourney.java similarity index 98% rename from src/main/java/lambdasinaction/chap13/PersistentTrainJourney.java rename to src/main/java/lambdasinaction/chap14/PersistentTrainJourney.java index 8569f57f..7e958a14 100644 --- a/src/main/java/lambdasinaction/chap13/PersistentTrainJourney.java +++ b/src/main/java/lambdasinaction/chap14/PersistentTrainJourney.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap13; +package lambdasinaction.chap14; import java.util.function.Consumer; diff --git a/src/main/java/lambdasinaction/chap13/PersistentTree.java b/src/main/java/lambdasinaction/chap14/PersistentTree.java similarity index 98% rename from src/main/java/lambdasinaction/chap13/PersistentTree.java rename to src/main/java/lambdasinaction/chap14/PersistentTree.java index e6b88b70..562d4f69 100644 --- a/src/main/java/lambdasinaction/chap13/PersistentTree.java +++ b/src/main/java/lambdasinaction/chap14/PersistentTree.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap13; +package lambdasinaction.chap14; public class PersistentTree { diff --git a/src/main/java/lambdasinaction/chap4/Reducing.java b/src/main/java/lambdasinaction/chap4/Reducing.java deleted file mode 100644 index 6bfc514d..00000000 --- a/src/main/java/lambdasinaction/chap4/Reducing.java +++ /dev/null @@ -1,29 +0,0 @@ -package lambdasinaction.chap4; -import java.util.stream.*; -import java.util.*; - -import static lambdasinaction.chap4.Dish.menu; - -public class Reducing{ - - public static void main(String...args){ - - List numbers = Arrays.asList(3,4,5,1,2); - int sum = numbers.stream().reduce(0, (a, b) -> a + b); - System.out.println(sum); - - int sum2 = numbers.stream().reduce(0, Integer::sum); - System.out.println(sum2); - - int max = numbers.stream().reduce(0, (a, b) -> Integer.max(a, b)); - System.out.println(max); - - Optional min = numbers.stream().reduce(Integer::min); - min.ifPresent(System.out::println); - - int calories = menu.stream() - .map(Dish::getCalories) - .reduce(0, Integer::sum); - System.out.println("Number of calories:" + calories); - } -} diff --git a/src/main/java/lambdasinaction/chap4/BuildingStreams.java b/src/main/java/lambdasinaction/chap5/BuildingStreams.java similarity index 95% rename from src/main/java/lambdasinaction/chap4/BuildingStreams.java rename to src/main/java/lambdasinaction/chap5/BuildingStreams.java index ecb2dcb3..15280a39 100644 --- a/src/main/java/lambdasinaction/chap4/BuildingStreams.java +++ b/src/main/java/lambdasinaction/chap5/BuildingStreams.java @@ -1,9 +1,8 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; import java.util.*; import java.util.function.IntSupplier; import java.util.stream.*; -import static java.util.stream.Collectors.toList; import java.nio.charset.Charset; import java.nio.file.*; @@ -67,7 +66,7 @@ public int getAsInt(){ }; IntStream.generate(fib).limit(10).forEach(System.out::println); - long uniqueWords = Files.lines(Paths.get("lambdasinaction/chap4/data.txt"), Charset.defaultCharset()) + long uniqueWords = Files.lines(Paths.get("lambdasinaction/chap5/data.txt"), Charset.defaultCharset()) .flatMap(line -> Arrays.stream(line.split(" "))) .distinct() .count(); diff --git a/src/main/java/lambdasinaction/chap4/Filtering.java b/src/main/java/lambdasinaction/chap5/Filtering.java similarity index 94% rename from src/main/java/lambdasinaction/chap4/Filtering.java rename to src/main/java/lambdasinaction/chap5/Filtering.java index adfc0d9c..066c8242 100644 --- a/src/main/java/lambdasinaction/chap4/Filtering.java +++ b/src/main/java/lambdasinaction/chap5/Filtering.java @@ -1,4 +1,6 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; +import lambdasinaction.chap4.*; + import java.util.stream.*; import java.util.*; import static java.util.stream.Collectors.toList; diff --git a/src/main/java/lambdasinaction/chap4/Finding.java b/src/main/java/lambdasinaction/chap5/Finding.java similarity index 94% rename from src/main/java/lambdasinaction/chap4/Finding.java rename to src/main/java/lambdasinaction/chap5/Finding.java index 9eade942..acccc543 100644 --- a/src/main/java/lambdasinaction/chap4/Finding.java +++ b/src/main/java/lambdasinaction/chap5/Finding.java @@ -1,4 +1,6 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; +import lambdasinaction.chap4.*; + import java.util.stream.*; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap4/Laziness.java b/src/main/java/lambdasinaction/chap5/Laziness.java similarity index 96% rename from src/main/java/lambdasinaction/chap4/Laziness.java rename to src/main/java/lambdasinaction/chap5/Laziness.java index 60446895..a3df328a 100644 --- a/src/main/java/lambdasinaction/chap4/Laziness.java +++ b/src/main/java/lambdasinaction/chap5/Laziness.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; import java.util.Arrays; import java.util.List; diff --git a/src/main/java/lambdasinaction/chap4/Mapping.java b/src/main/java/lambdasinaction/chap5/Mapping.java similarity index 95% rename from src/main/java/lambdasinaction/chap4/Mapping.java rename to src/main/java/lambdasinaction/chap5/Mapping.java index 9adf3c99..7bf4caba 100644 --- a/src/main/java/lambdasinaction/chap4/Mapping.java +++ b/src/main/java/lambdasinaction/chap5/Mapping.java @@ -1,4 +1,6 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; + +import lambdasinaction.chap4.*; import java.util.*; import static java.util.stream.Collectors.toList; diff --git a/src/main/java/lambdasinaction/chap4/NumericStreams.java b/src/main/java/lambdasinaction/chap5/NumericStreams.java similarity index 96% rename from src/main/java/lambdasinaction/chap4/NumericStreams.java rename to src/main/java/lambdasinaction/chap5/NumericStreams.java index 7822bf98..e5f8cca8 100644 --- a/src/main/java/lambdasinaction/chap4/NumericStreams.java +++ b/src/main/java/lambdasinaction/chap5/NumericStreams.java @@ -1,4 +1,6 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; +import lambdasinaction.chap4.*; + import java.util.stream.*; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap4/PuttingIntoPractice.java b/src/main/java/lambdasinaction/chap5/PuttingIntoPractice.java similarity index 98% rename from src/main/java/lambdasinaction/chap4/PuttingIntoPractice.java rename to src/main/java/lambdasinaction/chap5/PuttingIntoPractice.java index ae47f9a5..d0b13ae5 100644 --- a/src/main/java/lambdasinaction/chap4/PuttingIntoPractice.java +++ b/src/main/java/lambdasinaction/chap5/PuttingIntoPractice.java @@ -1,7 +1,9 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; + +import lambdasinaction.chap5.*; import java.util.*; -import java.util.stream.*; + import static java.util.Comparator.comparing; import static java.util.stream.Collectors.toList; diff --git a/src/main/java/lambdasinaction/chap5/Reducing.java b/src/main/java/lambdasinaction/chap5/Reducing.java index ae5d519e..93aed73e 100644 --- a/src/main/java/lambdasinaction/chap5/Reducing.java +++ b/src/main/java/lambdasinaction/chap5/Reducing.java @@ -1,34 +1,31 @@ package lambdasinaction.chap5; +import lambdasinaction.chap4.*; -import java.util.*; -import java.util.function.*; import java.util.stream.*; +import java.util.*; -import static java.util.stream.Collectors.*; -import static lambdasinaction.chap5.Dish.menu; +import static lambdasinaction.chap4.Dish.menu; -public class Reducing { +public class Reducing{ - public static void main(String ... args) { - System.out.println("Total calories in menu: " + calculateTotalCalories()); - System.out.println("Total calories in menu: " + calculateTotalCaloriesWithMethodReference()); - System.out.println("Total calories in menu: " + calculateTotalCaloriesWithoutCollectors()); - System.out.println("Total calories in menu: " + calculateTotalCaloriesUsingSum()); - } + public static void main(String...args){ - private static int calculateTotalCalories() { - return menu.stream().collect(reducing(0, Dish::getCalories, (Integer i, Integer j) -> i + j)); - } + List numbers = Arrays.asList(3,4,5,1,2); + int sum = numbers.stream().reduce(0, (a, b) -> a + b); + System.out.println(sum); - private static int calculateTotalCaloriesWithMethodReference() { - return menu.stream().collect(reducing(0, Dish::getCalories, Integer::sum)); - } + int sum2 = numbers.stream().reduce(0, Integer::sum); + System.out.println(sum2); - private static int calculateTotalCaloriesWithoutCollectors() { - return menu.stream().map(Dish::getCalories).reduce(Integer::sum).get(); - } + int max = numbers.stream().reduce(0, (a, b) -> Integer.max(a, b)); + System.out.println(max); + + Optional min = numbers.stream().reduce(Integer::min); + min.ifPresent(System.out::println); - private static int calculateTotalCaloriesUsingSum() { - return menu.stream().mapToInt(Dish::getCalories).sum(); + int calories = menu.stream() + .map(Dish::getCalories) + .reduce(0, Integer::sum); + System.out.println("Number of calories:" + calories); } -} \ No newline at end of file +} diff --git a/src/main/java/lambdasinaction/chap4/Trader.java b/src/main/java/lambdasinaction/chap5/Trader.java similarity index 92% rename from src/main/java/lambdasinaction/chap4/Trader.java rename to src/main/java/lambdasinaction/chap5/Trader.java index b8bb83c8..7487a8c6 100644 --- a/src/main/java/lambdasinaction/chap4/Trader.java +++ b/src/main/java/lambdasinaction/chap5/Trader.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; public class Trader{ private String name; diff --git a/src/main/java/lambdasinaction/chap4/Transaction.java b/src/main/java/lambdasinaction/chap5/Transaction.java similarity index 94% rename from src/main/java/lambdasinaction/chap4/Transaction.java rename to src/main/java/lambdasinaction/chap5/Transaction.java index 04da232b..754e3839 100644 --- a/src/main/java/lambdasinaction/chap4/Transaction.java +++ b/src/main/java/lambdasinaction/chap5/Transaction.java @@ -1,4 +1,5 @@ -package lambdasinaction.chap4; +package lambdasinaction.chap5; + public class Transaction{ private Trader trader; diff --git a/src/main/java/lambdasinaction/chap5/CollectorHarness.java b/src/main/java/lambdasinaction/chap6/CollectorHarness.java similarity index 89% rename from src/main/java/lambdasinaction/chap5/CollectorHarness.java rename to src/main/java/lambdasinaction/chap6/CollectorHarness.java index 3b46dab0..8370be16 100644 --- a/src/main/java/lambdasinaction/chap5/CollectorHarness.java +++ b/src/main/java/lambdasinaction/chap6/CollectorHarness.java @@ -1,9 +1,7 @@ -package lambdasinaction.chap5; +package lambdasinaction.chap6; import java.util.function.*; -import static lambdasinaction.chap5.PartitionPrimeNumbers.*; - public class CollectorHarness { public static void main(String[] args) { diff --git a/src/main/java/lambdasinaction/chap5/Dish.java b/src/main/java/lambdasinaction/chap6/Dish.java similarity index 97% rename from src/main/java/lambdasinaction/chap5/Dish.java rename to src/main/java/lambdasinaction/chap6/Dish.java index fab9f533..a353f1bc 100644 --- a/src/main/java/lambdasinaction/chap5/Dish.java +++ b/src/main/java/lambdasinaction/chap6/Dish.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap5; +package lambdasinaction.chap6; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap5/Grouping.java b/src/main/java/lambdasinaction/chap6/Grouping.java similarity index 96% rename from src/main/java/lambdasinaction/chap5/Grouping.java rename to src/main/java/lambdasinaction/chap6/Grouping.java index 9065d02f..bedb3470 100644 --- a/src/main/java/lambdasinaction/chap5/Grouping.java +++ b/src/main/java/lambdasinaction/chap6/Grouping.java @@ -1,11 +1,9 @@ -package lambdasinaction.chap5; +package lambdasinaction.chap6; import java.util.*; -import java.util.function.*; -import java.util.stream.*; import static java.util.stream.Collectors.*; -import static lambdasinaction.chap5.Dish.menu; +import static lambdasinaction.chap6.Dish.menu; public class Grouping { diff --git a/src/main/java/lambdasinaction/chap5/GroupingTransactions.java b/src/main/java/lambdasinaction/chap6/GroupingTransactions.java similarity index 99% rename from src/main/java/lambdasinaction/chap5/GroupingTransactions.java rename to src/main/java/lambdasinaction/chap6/GroupingTransactions.java index db075913..ce358acb 100644 --- a/src/main/java/lambdasinaction/chap5/GroupingTransactions.java +++ b/src/main/java/lambdasinaction/chap6/GroupingTransactions.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap5; +package lambdasinaction.chap6; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap5/PartitionPrimeNumbers.java b/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java similarity index 98% rename from src/main/java/lambdasinaction/chap5/PartitionPrimeNumbers.java rename to src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java index 26b07c70..5122a6a3 100644 --- a/src/main/java/lambdasinaction/chap5/PartitionPrimeNumbers.java +++ b/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java @@ -1,11 +1,10 @@ -package lambdasinaction.chap5; +package lambdasinaction.chap6; import java.util.*; import java.util.function.*; import java.util.stream.*; import static java.util.stream.Collectors.*; -import static lambdasinaction.chap5.Dish.menu; import static java.util.stream.Collector.Characteristics.*; public class PartitionPrimeNumbers { diff --git a/src/main/java/lambdasinaction/chap5/Partitioning.java b/src/main/java/lambdasinaction/chap6/Partitioning.java similarity index 89% rename from src/main/java/lambdasinaction/chap5/Partitioning.java rename to src/main/java/lambdasinaction/chap6/Partitioning.java index 4b491896..2ec8dc79 100644 --- a/src/main/java/lambdasinaction/chap5/Partitioning.java +++ b/src/main/java/lambdasinaction/chap6/Partitioning.java @@ -1,12 +1,10 @@ -package lambdasinaction.chap5; +package lambdasinaction.chap6; import java.util.*; -import java.util.function.*; -import java.util.stream.*; import static java.util.Comparator.comparingInt; import static java.util.stream.Collectors.*; -import static lambdasinaction.chap5.Dish.menu; +import static lambdasinaction.chap6.Dish.menu; public class Partitioning { diff --git a/src/main/java/lambdasinaction/chap6/Reducing.java b/src/main/java/lambdasinaction/chap6/Reducing.java new file mode 100644 index 00000000..fb7cf971 --- /dev/null +++ b/src/main/java/lambdasinaction/chap6/Reducing.java @@ -0,0 +1,30 @@ +package lambdasinaction.chap6; + +import static java.util.stream.Collectors.*; +import static lambdasinaction.chap6.Dish.menu; + +public class Reducing { + + public static void main(String ... args) { + System.out.println("Total calories in menu: " + calculateTotalCalories()); + System.out.println("Total calories in menu: " + calculateTotalCaloriesWithMethodReference()); + System.out.println("Total calories in menu: " + calculateTotalCaloriesWithoutCollectors()); + System.out.println("Total calories in menu: " + calculateTotalCaloriesUsingSum()); + } + + private static int calculateTotalCalories() { + return menu.stream().collect(reducing(0, Dish::getCalories, (Integer i, Integer j) -> i + j)); + } + + private static int calculateTotalCaloriesWithMethodReference() { + return menu.stream().collect(reducing(0, Dish::getCalories, Integer::sum)); + } + + private static int calculateTotalCaloriesWithoutCollectors() { + return menu.stream().map(Dish::getCalories).reduce(Integer::sum).get(); + } + + private static int calculateTotalCaloriesUsingSum() { + return menu.stream().mapToInt(Dish::getCalories).sum(); + } +} \ No newline at end of file diff --git a/src/main/java/lambdasinaction/chap5/Summarizing.java b/src/main/java/lambdasinaction/chap6/Summarizing.java similarity index 95% rename from src/main/java/lambdasinaction/chap5/Summarizing.java rename to src/main/java/lambdasinaction/chap6/Summarizing.java index 5e99b6cc..06f9af6d 100644 --- a/src/main/java/lambdasinaction/chap5/Summarizing.java +++ b/src/main/java/lambdasinaction/chap6/Summarizing.java @@ -1,11 +1,10 @@ -package lambdasinaction.chap5; +package lambdasinaction.chap6; import java.util.*; import java.util.function.*; -import java.util.stream.*; import static java.util.stream.Collectors.*; -import static lambdasinaction.chap5.Dish.menu; +import static lambdasinaction.chap6.Dish.menu; public class Summarizing { diff --git a/src/main/java/lambdasinaction/chap5/ToListCollector.java b/src/main/java/lambdasinaction/chap6/ToListCollector.java similarity index 96% rename from src/main/java/lambdasinaction/chap5/ToListCollector.java rename to src/main/java/lambdasinaction/chap6/ToListCollector.java index 19edcd6c..0621d96a 100644 --- a/src/main/java/lambdasinaction/chap5/ToListCollector.java +++ b/src/main/java/lambdasinaction/chap6/ToListCollector.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap5; +package lambdasinaction.chap6; import java.util.*; import java.util.function.*; diff --git a/src/main/java/lambdasinaction/chap6/ForkJoinSumCalculator.java b/src/main/java/lambdasinaction/chap7/ForkJoinSumCalculator.java similarity index 91% rename from src/main/java/lambdasinaction/chap6/ForkJoinSumCalculator.java rename to src/main/java/lambdasinaction/chap7/ForkJoinSumCalculator.java index 90a6e781..8f74a90a 100644 --- a/src/main/java/lambdasinaction/chap6/ForkJoinSumCalculator.java +++ b/src/main/java/lambdasinaction/chap7/ForkJoinSumCalculator.java @@ -1,11 +1,10 @@ -package lambdasinaction.chap6; +package lambdasinaction.chap7; import java.util.concurrent.RecursiveTask; -import java.util.concurrent.ForkJoinPool; import java.util.concurrent.ForkJoinTask; import java.util.stream.LongStream; -import static lambdasinaction.chap6.ParallelStreamsHarness.FORK_JOIN_POOL; +import static lambdasinaction.chap7.ParallelStreamsHarness.FORK_JOIN_POOL; public class ForkJoinSumCalculator extends RecursiveTask { diff --git a/src/main/java/lambdasinaction/chap6/ParallelStreams.java b/src/main/java/lambdasinaction/chap7/ParallelStreams.java similarity index 97% rename from src/main/java/lambdasinaction/chap6/ParallelStreams.java rename to src/main/java/lambdasinaction/chap7/ParallelStreams.java index 152e8919..e8b2a520 100644 --- a/src/main/java/lambdasinaction/chap6/ParallelStreams.java +++ b/src/main/java/lambdasinaction/chap7/ParallelStreams.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap6; +package lambdasinaction.chap7; import java.util.stream.*; diff --git a/src/main/java/lambdasinaction/chap6/ParallelStreamsHarness.java b/src/main/java/lambdasinaction/chap7/ParallelStreamsHarness.java similarity index 98% rename from src/main/java/lambdasinaction/chap6/ParallelStreamsHarness.java rename to src/main/java/lambdasinaction/chap7/ParallelStreamsHarness.java index 6a6c4fb6..7d53c86f 100644 --- a/src/main/java/lambdasinaction/chap6/ParallelStreamsHarness.java +++ b/src/main/java/lambdasinaction/chap7/ParallelStreamsHarness.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap6; +package lambdasinaction.chap7; import java.util.concurrent.*; import java.util.function.*; diff --git a/src/main/java/lambdasinaction/chap6/WordCount.java b/src/main/java/lambdasinaction/chap7/WordCount.java similarity index 99% rename from src/main/java/lambdasinaction/chap6/WordCount.java rename to src/main/java/lambdasinaction/chap7/WordCount.java index 762e0355..13ccce52 100644 --- a/src/main/java/lambdasinaction/chap6/WordCount.java +++ b/src/main/java/lambdasinaction/chap7/WordCount.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap6; +package lambdasinaction.chap7; import java.util.*; import java.util.function.*; diff --git a/src/main/java/lambdasinaction/chap7/ChainOfResponsibilityMain.java b/src/main/java/lambdasinaction/chap8/ChainOfResponsibilityMain.java similarity index 98% rename from src/main/java/lambdasinaction/chap7/ChainOfResponsibilityMain.java rename to src/main/java/lambdasinaction/chap8/ChainOfResponsibilityMain.java index 84ff8208..91d52e0a 100644 --- a/src/main/java/lambdasinaction/chap7/ChainOfResponsibilityMain.java +++ b/src/main/java/lambdasinaction/chap8/ChainOfResponsibilityMain.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap7; +package lambdasinaction.chap8; import java.util.function.Function; import java.util.function.UnaryOperator; diff --git a/src/main/java/lambdasinaction/chap7/Debugging.java b/src/main/java/lambdasinaction/chap8/Debugging.java similarity index 94% rename from src/main/java/lambdasinaction/chap7/Debugging.java rename to src/main/java/lambdasinaction/chap8/Debugging.java index 7677a2a8..40c4dd23 100644 --- a/src/main/java/lambdasinaction/chap7/Debugging.java +++ b/src/main/java/lambdasinaction/chap8/Debugging.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap7; +package lambdasinaction.chap8; import java.util.*; diff --git a/src/main/java/lambdasinaction/chap7/FactoryMain.java b/src/main/java/lambdasinaction/chap8/FactoryMain.java similarity index 97% rename from src/main/java/lambdasinaction/chap7/FactoryMain.java rename to src/main/java/lambdasinaction/chap8/FactoryMain.java index 83d69abc..2081f120 100644 --- a/src/main/java/lambdasinaction/chap7/FactoryMain.java +++ b/src/main/java/lambdasinaction/chap8/FactoryMain.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap7; +package lambdasinaction.chap8; import java.util.HashMap; import java.util.Map; diff --git a/src/main/java/lambdasinaction/chap7/ObserverMain.java b/src/main/java/lambdasinaction/chap8/ObserverMain.java similarity index 96% rename from src/main/java/lambdasinaction/chap7/ObserverMain.java rename to src/main/java/lambdasinaction/chap8/ObserverMain.java index 37291977..dcd8cb50 100644 --- a/src/main/java/lambdasinaction/chap7/ObserverMain.java +++ b/src/main/java/lambdasinaction/chap8/ObserverMain.java @@ -1,9 +1,7 @@ -package lambdasinaction.chap7; +package lambdasinaction.chap8; import java.util.ArrayList; import java.util.List; -import java.util.Observable; -import java.util.Observer; public class ObserverMain { diff --git a/src/main/java/lambdasinaction/chap7/OnlineBanking.java b/src/main/java/lambdasinaction/chap8/OnlineBanking.java similarity index 93% rename from src/main/java/lambdasinaction/chap7/OnlineBanking.java rename to src/main/java/lambdasinaction/chap8/OnlineBanking.java index 7e8b6930..27cbf917 100644 --- a/src/main/java/lambdasinaction/chap7/OnlineBanking.java +++ b/src/main/java/lambdasinaction/chap8/OnlineBanking.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap7; +package lambdasinaction.chap8; abstract class OnlineBanking { diff --git a/src/main/java/lambdasinaction/chap7/OnlineBankingLambda.java b/src/main/java/lambdasinaction/chap8/OnlineBankingLambda.java similarity index 95% rename from src/main/java/lambdasinaction/chap7/OnlineBankingLambda.java rename to src/main/java/lambdasinaction/chap8/OnlineBankingLambda.java index 235bf249..3bd9e049 100644 --- a/src/main/java/lambdasinaction/chap7/OnlineBankingLambda.java +++ b/src/main/java/lambdasinaction/chap8/OnlineBankingLambda.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap7; +package lambdasinaction.chap8; import java.util.function.Consumer; diff --git a/src/main/java/lambdasinaction/chap7/Peek.java b/src/main/java/lambdasinaction/chap8/Peek.java similarity index 94% rename from src/main/java/lambdasinaction/chap7/Peek.java rename to src/main/java/lambdasinaction/chap8/Peek.java index 1c0192ee..e25d68a4 100644 --- a/src/main/java/lambdasinaction/chap7/Peek.java +++ b/src/main/java/lambdasinaction/chap8/Peek.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap7; +package lambdasinaction.chap8; import java.util.List; import java.util.stream.Stream; diff --git a/src/main/java/lambdasinaction/chap7/StrategyMain.java b/src/main/java/lambdasinaction/chap8/StrategyMain.java similarity index 97% rename from src/main/java/lambdasinaction/chap7/StrategyMain.java rename to src/main/java/lambdasinaction/chap8/StrategyMain.java index d670b734..cc899aa8 100644 --- a/src/main/java/lambdasinaction/chap7/StrategyMain.java +++ b/src/main/java/lambdasinaction/chap8/StrategyMain.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap7; +package lambdasinaction.chap8; public class StrategyMain { diff --git a/src/main/java/lambdasinaction/chap8/Ambiguous.java b/src/main/java/lambdasinaction/chap9/Ambiguous.java similarity index 93% rename from src/main/java/lambdasinaction/chap8/Ambiguous.java rename to src/main/java/lambdasinaction/chap9/Ambiguous.java index 1c856e61..d007bedc 100644 --- a/src/main/java/lambdasinaction/chap8/Ambiguous.java +++ b/src/main/java/lambdasinaction/chap9/Ambiguous.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; public class Ambiguous{ diff --git a/src/main/java/lambdasinaction/chap8/Diamond.java b/src/main/java/lambdasinaction/chap9/Diamond.java similarity index 91% rename from src/main/java/lambdasinaction/chap8/Diamond.java rename to src/main/java/lambdasinaction/chap9/Diamond.java index a02a8621..f0226e1d 100644 --- a/src/main/java/lambdasinaction/chap8/Diamond.java +++ b/src/main/java/lambdasinaction/chap9/Diamond.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; public class Diamond{ diff --git a/src/main/java/lambdasinaction/chap8/Drawable.java b/src/main/java/lambdasinaction/chap9/Drawable.java similarity index 77% rename from src/main/java/lambdasinaction/chap8/Drawable.java rename to src/main/java/lambdasinaction/chap9/Drawable.java index 981b5575..731a8772 100644 --- a/src/main/java/lambdasinaction/chap8/Drawable.java +++ b/src/main/java/lambdasinaction/chap9/Drawable.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; /** * Created by raoul-gabrielurma on 15/01/2014. diff --git a/src/main/java/lambdasinaction/chap8/Ellipse.java b/src/main/java/lambdasinaction/chap9/Ellipse.java similarity index 93% rename from src/main/java/lambdasinaction/chap8/Ellipse.java rename to src/main/java/lambdasinaction/chap9/Ellipse.java index 1912558f..8f2d1ae0 100644 --- a/src/main/java/lambdasinaction/chap8/Ellipse.java +++ b/src/main/java/lambdasinaction/chap9/Ellipse.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; /** * Created by raoul-gabrielurma on 15/01/2014. diff --git a/src/main/java/lambdasinaction/chap8/Game.java b/src/main/java/lambdasinaction/chap9/Game.java similarity index 90% rename from src/main/java/lambdasinaction/chap8/Game.java rename to src/main/java/lambdasinaction/chap9/Game.java index 917626e7..0836f46c 100644 --- a/src/main/java/lambdasinaction/chap8/Game.java +++ b/src/main/java/lambdasinaction/chap9/Game.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; import java.util.Arrays; diff --git a/src/main/java/lambdasinaction/chap8/Intro.java b/src/main/java/lambdasinaction/chap9/Intro.java similarity index 92% rename from src/main/java/lambdasinaction/chap8/Intro.java rename to src/main/java/lambdasinaction/chap9/Intro.java index 09b010d7..d540a705 100644 --- a/src/main/java/lambdasinaction/chap8/Intro.java +++ b/src/main/java/lambdasinaction/chap9/Intro.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; import java.util.Arrays; import java.util.Comparator; diff --git a/src/main/java/lambdasinaction/chap8/Letter.java b/src/main/java/lambdasinaction/chap9/Letter.java similarity index 95% rename from src/main/java/lambdasinaction/chap8/Letter.java rename to src/main/java/lambdasinaction/chap9/Letter.java index cea01ccb..2ff65193 100644 --- a/src/main/java/lambdasinaction/chap8/Letter.java +++ b/src/main/java/lambdasinaction/chap9/Letter.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; import java.util.function.Function; diff --git a/src/main/java/lambdasinaction/chap8/MostSpecific.java b/src/main/java/lambdasinaction/chap9/MostSpecific.java similarity index 95% rename from src/main/java/lambdasinaction/chap8/MostSpecific.java rename to src/main/java/lambdasinaction/chap9/MostSpecific.java index c9198235..2a845e72 100644 --- a/src/main/java/lambdasinaction/chap8/MostSpecific.java +++ b/src/main/java/lambdasinaction/chap9/MostSpecific.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; public class MostSpecific{ diff --git a/src/main/java/lambdasinaction/chap8/README b/src/main/java/lambdasinaction/chap9/README similarity index 100% rename from src/main/java/lambdasinaction/chap8/README rename to src/main/java/lambdasinaction/chap9/README diff --git a/src/main/java/lambdasinaction/chap8/Resizable.java b/src/main/java/lambdasinaction/chap9/Resizable.java similarity index 92% rename from src/main/java/lambdasinaction/chap8/Resizable.java rename to src/main/java/lambdasinaction/chap9/Resizable.java index 450ba4d5..c197b2bb 100644 --- a/src/main/java/lambdasinaction/chap8/Resizable.java +++ b/src/main/java/lambdasinaction/chap9/Resizable.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; public interface Resizable extends Drawable{ public int getWidth(); diff --git a/src/main/java/lambdasinaction/chap8/Square.java b/src/main/java/lambdasinaction/chap9/Square.java similarity index 93% rename from src/main/java/lambdasinaction/chap8/Square.java rename to src/main/java/lambdasinaction/chap9/Square.java index b77c439e..11c2397f 100644 --- a/src/main/java/lambdasinaction/chap8/Square.java +++ b/src/main/java/lambdasinaction/chap9/Square.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; /** * Created by raoul-gabrielurma on 15/01/2014. diff --git a/src/main/java/lambdasinaction/chap8/Triangle.java b/src/main/java/lambdasinaction/chap9/Triangle.java similarity index 93% rename from src/main/java/lambdasinaction/chap8/Triangle.java rename to src/main/java/lambdasinaction/chap9/Triangle.java index 03cbab22..ab98fa72 100644 --- a/src/main/java/lambdasinaction/chap8/Triangle.java +++ b/src/main/java/lambdasinaction/chap9/Triangle.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; /** * Created by raoul-gabrielurma on 15/01/2014. diff --git a/src/main/java/lambdasinaction/chap8/Utils.java b/src/main/java/lambdasinaction/chap9/Utils.java similarity index 89% rename from src/main/java/lambdasinaction/chap8/Utils.java rename to src/main/java/lambdasinaction/chap9/Utils.java index 2967e703..9e2af4bd 100644 --- a/src/main/java/lambdasinaction/chap8/Utils.java +++ b/src/main/java/lambdasinaction/chap9/Utils.java @@ -1,4 +1,4 @@ -package lambdasinaction.chap8; +package lambdasinaction.chap9; import java.util.List; diff --git a/src/main/resources/lambdasinaction/chap4/data.txt b/src/main/resources/lambdasinaction/chap5/data.txt similarity index 100% rename from src/main/resources/lambdasinaction/chap4/data.txt rename to src/main/resources/lambdasinaction/chap5/data.txt From 14f46f10ff4ce832040a866e8e58bbbb0de29d97 Mon Sep 17 00:00:00 2001 From: raoulDoc Date: Tue, 15 Jul 2014 23:05:03 +0100 Subject: [PATCH 05/12] Update ToC --- README.md | 30 +++++++++++++++++------------- 1 file changed, 17 insertions(+), 13 deletions(-) diff --git a/README.md b/README.md index 73664d8a..1fcbfc32 100644 --- a/README.md +++ b/README.md @@ -12,19 +12,23 @@ The source code for all examples can be found in the directory [src/main/java/la * Chapter 1: Java 8: why should you care? * Chapter 2: Passing code with behavior parameterization * Chapter 3: Lambda expressions -* Chapter 4: Processing data with streams -* Chapter 5: Collecting data with streams -* Chapter 6: Parallel data processing and performance -* Chapter 7: Refactoring, testing, debugging -* Chapter 8: Default methods -* Chapter 9: Optional: a better alternative to null -* Chapter 10: CompletableFuture: composable asynchronous programming -* Chapter 11: New Date and Time API -* Chapter 12: Thinking functionally -* Chapter 13: Functional programming techniques -* Chapter 14: Blending OOP and FP: comparing Java 8 and Scala -* Chapter 15: Conclusions and "where next" for Java - +* Chapter 4: Working with Streams +* Chapter 5: Processing data with streams +* Chapter 6: Collecting data with streams +* Chapter 7: Parallel data processing and performance +* Chapter 8: Refactoring, testing, debugging +* Chapter 9: Default methods +* Chapter 10: Using Optional as a better alternative to null +* Chapter 11: CompletableFuture: composable asynchronous programming +* Chapter 12: New Date and Time API +* Chapter 13: Thinking functionally +* Chapter 14: Functional programming techniques +* Chapter 15: Blending OOP and FP: comparing Java 8 and Scala +* Chapter 16: Conclusions and "where next" for Java +* Appendix A: Miscellaneous language updates +* Appendix B: Miscellaneous library updates +* Appendix C: Performing multiple operations in parallel on a Stream +* Appendix D: Lambdas and JVM bytecode We will update the repository as we update the book. Stay tuned! ### Make sure to have JDK8 installed From b5e879ce6643bcf9b50e79cc3a7cc39d445884e4 Mon Sep 17 00:00:00 2001 From: raoulDoc Date: Tue, 15 Jul 2014 23:10:40 +0100 Subject: [PATCH 06/12] fix static init --- src/main/java/lambdasinaction/chap8/FactoryMain.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/lambdasinaction/chap8/FactoryMain.java b/src/main/java/lambdasinaction/chap8/FactoryMain.java index 2081f120..e30d219e 100644 --- a/src/main/java/lambdasinaction/chap8/FactoryMain.java +++ b/src/main/java/lambdasinaction/chap8/FactoryMain.java @@ -40,7 +40,7 @@ static private class Stock implements Product {} static private class Bond implements Product {} final static private Map> map = new HashMap<>(); - { + static { map.put("loan", Loan::new); map.put("stock", Stock::new); map.put("bond", Bond::new); From 93fec84e6418bcc307683f41f550d39cf0e67833 Mon Sep 17 00:00:00 2001 From: raoulDoc Date: Fri, 19 Sep 2014 17:29:09 +0100 Subject: [PATCH 07/12] Update README.md --- README.md | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/README.md b/README.md index 1fcbfc32..4b42901e 100644 --- a/README.md +++ b/README.md @@ -3,9 +3,7 @@ Java8InAction This repository contains all the source code for the examples and quizzes in the book Java 8 in Action: Lambdas, Streams and functional-style programming. -You can purchase the early access here: [http://manning.com/urma/](http://manning.com/urma/) - -We are very keen to hear your feedback and improve the book based on your comments! +You can purchase the book here: [http://manning.com/urma/](http://manning.com/urma/) or on Amazon The source code for all examples can be found in the directory [src/main/java/lambdasinaction](https://github.com/java8/Java8InAction/tree/master/src/main/java/lambdasinaction) From 44ded1b0f38dcadb0b2ee5c32c85b40849a851e5 Mon Sep 17 00:00:00 2001 From: kagan770 Date: Mon, 18 Jan 2016 17:36:30 -0800 Subject: [PATCH 08/12] Updated READ.ME file --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index 4b42901e..9ee848d5 100644 --- a/README.md +++ b/README.md @@ -52,3 +52,8 @@ $ java lambdasinaction/chap1/FilteringApples Alternatively you can compile the files manually inside the directory src/main/java + +You can also import the project in your favorite IDE: + * In IntelliJ use "File->Open" menu and navigate to the folder where the project resides + * In Eclipse use "File->Import->Existing Maven Projects" (also modify "Reduntant super interfaces" to report as Warnings instead of Errors + * In Netbeans use "File->Open Project" menu \ No newline at end of file From df8e05f771d61338255b4ebe7fe0f95928727e10 Mon Sep 17 00:00:00 2001 From: Mario Fusco Date: Wed, 23 Mar 2016 19:21:20 +0100 Subject: [PATCH 09/12] dsl chapter --- .../java/lambdasinaction/dsl/Grouping.java | 79 +++++++++++++++ .../dsl/LambdaOrderBuilder.java | 83 ++++++++++++++++ src/main/java/lambdasinaction/dsl/Main.java | 98 ++++++++++++++++++ .../dsl/MethodChainingOrderBuilder.java | 99 +++++++++++++++++++ src/main/java/lambdasinaction/dsl/Mixed.java | 39 ++++++++ .../lambdasinaction/dsl/MixedBuilder.java | 85 ++++++++++++++++ .../dsl/NestedFunctionOrderBuilder.java | 64 ++++++++++++ .../lambdasinaction/dsl/TaxCalculator.java | 81 +++++++++++++++ .../java/lambdasinaction/dsl/model/Order.java | 43 ++++++++ .../java/lambdasinaction/dsl/model/Stock.java | 40 ++++++++ .../java/lambdasinaction/dsl/model/Tax.java | 31 ++++++ .../java/lambdasinaction/dsl/model/Trade.java | 66 +++++++++++++ 12 files changed, 808 insertions(+) create mode 100644 src/main/java/lambdasinaction/dsl/Grouping.java create mode 100644 src/main/java/lambdasinaction/dsl/LambdaOrderBuilder.java create mode 100644 src/main/java/lambdasinaction/dsl/Main.java create mode 100644 src/main/java/lambdasinaction/dsl/MethodChainingOrderBuilder.java create mode 100644 src/main/java/lambdasinaction/dsl/Mixed.java create mode 100644 src/main/java/lambdasinaction/dsl/MixedBuilder.java create mode 100644 src/main/java/lambdasinaction/dsl/NestedFunctionOrderBuilder.java create mode 100644 src/main/java/lambdasinaction/dsl/TaxCalculator.java create mode 100644 src/main/java/lambdasinaction/dsl/model/Order.java create mode 100644 src/main/java/lambdasinaction/dsl/model/Stock.java create mode 100644 src/main/java/lambdasinaction/dsl/model/Tax.java create mode 100644 src/main/java/lambdasinaction/dsl/model/Trade.java diff --git a/src/main/java/lambdasinaction/dsl/Grouping.java b/src/main/java/lambdasinaction/dsl/Grouping.java new file mode 100644 index 00000000..698764d5 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/Grouping.java @@ -0,0 +1,79 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl; + +import lambdasinaction.chap5.Dish; + +import java.util.List; +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collector; + +import static java.util.stream.Collectors.groupingBy; +import static lambdasinaction.chap5.Dish.menu; +import static lambdasinaction.dsl.Grouping.GroupingBuilder.groupOn; + +public class Grouping { + + enum CaloricLevel { DIET, NORMAL, FAT }; + + public static void main(String ... args) { + System.out.println("Dishes grouped by type and caloric level: " + groupDishedByTypeAndCaloricLevel2()); + System.out.println("Dishes grouped by type and caloric level: " + groupDishedByTypeAndCaloricLevel3()); + } + + private static CaloricLevel getCaloricLevel( Dish dish ) { + if (dish.getCalories() <= 400) return CaloricLevel.DIET; + else if (dish.getCalories() <= 700) return CaloricLevel.NORMAL; + else return CaloricLevel.FAT; + } + + private static Map>> groupDishedByTypeAndCaloricLevel2() { + return menu.stream().collect( + twoLevelGroupingBy(Dish::getType, dish -> getCaloricLevel( dish ) ) + ); + } + + public static Collector>>> twoLevelGroupingBy(Function f1, Function f2) { + return groupingBy(f1, groupingBy(f2)); + } + + private static Map>> groupDishedByTypeAndCaloricLevel3() { + Collector>>> c = groupOn( ( Dish dish ) -> getCaloricLevel( dish ) ).after( Dish::getType ).get(); + return menu.stream().collect( c ); + } + + public static class GroupingBuilder { + private final Collector> collector; + + public GroupingBuilder( Collector> collector ) { + this.collector = collector; + } + + public Collector> get() { + return collector; + } + + public GroupingBuilder, J> after(Function classifier) { + return new GroupingBuilder<>( groupingBy( classifier, collector ) ); + } + + public static GroupingBuilder, K> groupOn(Function classifier) { + return new GroupingBuilder<>( groupingBy( classifier ) ); + } + } +} diff --git a/src/main/java/lambdasinaction/dsl/LambdaOrderBuilder.java b/src/main/java/lambdasinaction/dsl/LambdaOrderBuilder.java new file mode 100644 index 00000000..6746c3b1 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/LambdaOrderBuilder.java @@ -0,0 +1,83 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl; + +import lambdasinaction.dsl.model.Order; +import lambdasinaction.dsl.model.Stock; +import lambdasinaction.dsl.model.Trade; + +import java.util.function.Consumer; + +public class LambdaOrderBuilder { + + private Order order = new Order(); + + public static Order order(Consumer consumer) { + LambdaOrderBuilder builder = new LambdaOrderBuilder(); + consumer.accept( builder ); + return builder.order; + } + + public void forCustomer(String customer) { + order.setCustomer( customer ); + } + + public void buy(Consumer consumer) { + trade( consumer, Trade.Type.BUY ); + } + + public void sell(Consumer consumer) { + trade( consumer, Trade.Type.SELL ); + } + + private void trade( Consumer consumer, Trade.Type type ) { + TradeBuilder builder = new TradeBuilder(); + builder.trade.setType( type ); + consumer.accept( builder ); + order.addTrade( builder.trade ); + } + + public static class TradeBuilder { + private Trade trade = new Trade(); + + public void quantity(int quantity) { + trade.setQuantity( quantity ); + } + + public void price(double price) { + trade.setPrice( price ); + } + + public void stock(Consumer consumer) { + StockBuilder builder = new StockBuilder(); + consumer.accept( builder ); + trade.setStock( builder.stock ); + } + } + + public static class StockBuilder { + private Stock stock = new Stock(); + + public void symbol(String symbol) { + stock.setSymbol( symbol ); + } + + public void market(String market) { + stock.setMarket( market ); + } + } +} diff --git a/src/main/java/lambdasinaction/dsl/Main.java b/src/main/java/lambdasinaction/dsl/Main.java new file mode 100644 index 00000000..b50683e5 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/Main.java @@ -0,0 +1,98 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl; + +import lambdasinaction.dsl.model.Order; +import lambdasinaction.dsl.model.Stock; +import lambdasinaction.dsl.model.Trade; + +import static lambdasinaction.dsl.MethodChainingOrderBuilder.forCustomer; +import static lambdasinaction.dsl.NestedFunctionOrderBuilder.*; + +public class Main { + + public void plain() { + Order order = new Order(); + order.setCustomer( "BigBank" ); + + Trade trade1 = new Trade(); + trade1.setType( Trade.Type.BUY ); + + Stock stock1 = new Stock(); + stock1.setSymbol( "IBM" ); + stock1.setMarket( "NYSE" ); + + trade1.setStock( stock1 ); + trade1.setPrice( 125.00 ); + trade1.setQuantity( 80 ); + order.addTrade( trade1 ); + + Trade trade2 = new Trade(); + trade2.setType( Trade.Type.BUY ); + + Stock stock2 = new Stock(); + stock2.setSymbol( "GOOGLE" ); + stock2.setMarket( "NASDAQ" ); + + trade2.setStock( stock2 ); + trade2.setPrice( 375.00 ); + trade2.setQuantity( 50 ); + order.addTrade( trade2 ); + } + + public void methodChaining() { + Order order = forCustomer( "BigBank" ) + .buy( 80 ).stock( "IBM" ).on( "NYSE" ).at( 125.00 ) + .sell( 50 ).stock( "GOOGLE" ).on( "NASDAQ" ).at( 375.00 ) + .end(); + + } + + public void nestedFunction() { + Order order = order("BigBank", + buy(80, + stock( "IBM", on( "NYSE" ) ), + at(125.00)), + sell(50, + stock("GOOGLE", on("NASDAQ")), + at(375.00)) + ); + } + + public void lambda() { + Order order = LambdaOrderBuilder.order( o -> { + o.forCustomer( "BigBank" ); + o.buy( t -> { + t.quantity( 80 ); + t.price( 125.00 ); + t.stock( s -> { + s.symbol( "IBM" ); + s.market( "NYSE" ); + } ); + }); + o.sell( t -> { + t.quantity( 50 ); + t.price( 375.00 ); + t.stock( s -> { + s.symbol( "GOOGLE" ); + s.market( "NASDAQ" ); + } ); + }); + } ); + } + +} diff --git a/src/main/java/lambdasinaction/dsl/MethodChainingOrderBuilder.java b/src/main/java/lambdasinaction/dsl/MethodChainingOrderBuilder.java new file mode 100644 index 00000000..7d771ec5 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/MethodChainingOrderBuilder.java @@ -0,0 +1,99 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl; + +import lambdasinaction.dsl.model.Order; +import lambdasinaction.dsl.model.Stock; +import lambdasinaction.dsl.model.Trade; + +public class MethodChainingOrderBuilder { + + public final Order order = new Order(); + + private MethodChainingOrderBuilder(String customer) { + order.setCustomer( customer ); + } + + public static MethodChainingOrderBuilder forCustomer( String customer ) { + return new MethodChainingOrderBuilder(customer); + } + + public Order end() { + return order; + } + + public TradeBuilder buy(int quantity) { + return new TradeBuilder( this, Trade.Type.BUY, quantity ); + } + + public TradeBuilder sell(int quantity) { + return new TradeBuilder( this, Trade.Type.SELL, quantity ); + } + + private MethodChainingOrderBuilder addTrade(Trade trade) { + order.addTrade( trade ); + return this; + } + + public static class TradeBuilder { + private final MethodChainingOrderBuilder builder; + public final Trade trade = new Trade(); + + private TradeBuilder(MethodChainingOrderBuilder builder, Trade.Type type, int quantity) { + this.builder = builder; + trade.setType( type ); + trade.setQuantity( quantity ); + } + + public StockBuilder stock(String symbol) { + return new StockBuilder( builder, trade, symbol ); + } + } + + public static class TradeBuilderWithStock { + private final MethodChainingOrderBuilder builder; + private final Trade trade; + + public TradeBuilderWithStock( MethodChainingOrderBuilder builder, Trade trade ) { + this.builder = builder; + this.trade = trade; + } + + public MethodChainingOrderBuilder at(double price) { + trade.setPrice( price ); + return builder.addTrade( trade ); + } + } + + public static class StockBuilder { + private final MethodChainingOrderBuilder builder; + private final Trade trade; + private final Stock stock = new Stock(); + + private StockBuilder(MethodChainingOrderBuilder builder, Trade trade, String symbol) { + this.builder = builder; + this.trade = trade; + stock.setSymbol( symbol ); + } + + public TradeBuilderWithStock on(String market) { + stock.setMarket( market ); + trade.setStock( stock ); + return new TradeBuilderWithStock( builder, trade ); + } + } +} diff --git a/src/main/java/lambdasinaction/dsl/Mixed.java b/src/main/java/lambdasinaction/dsl/Mixed.java new file mode 100644 index 00000000..132dd998 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/Mixed.java @@ -0,0 +1,39 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl; + +import lambdasinaction.dsl.model.Order; + +import static lambdasinaction.dsl.MixedBuilder.buy; +import static lambdasinaction.dsl.MixedBuilder.sell; +import static lambdasinaction.dsl.MixedBuilder.forCustomer; + +public class Mixed { + public void mixed() { + Order order = + forCustomer( "BigBank", + buy( t -> t.quantity( 80 ) + .stock( "IBM" ) + .on( "NYSE" ) + .at( 125.00 )), + sell( t -> t.quantity( 50 ) + .stock( "GOOGLE" ) + .on( "NASDAQ" ) + .at( 125.00 )) ); + + } +} diff --git a/src/main/java/lambdasinaction/dsl/MixedBuilder.java b/src/main/java/lambdasinaction/dsl/MixedBuilder.java new file mode 100644 index 00000000..98d7ea97 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/MixedBuilder.java @@ -0,0 +1,85 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl; + +import lambdasinaction.dsl.model.Order; +import lambdasinaction.dsl.model.Stock; +import lambdasinaction.dsl.model.Trade; + +import java.util.function.Consumer; +import java.util.stream.Stream; + +public class MixedBuilder { + + public static Order forCustomer(String customer, TradeBuilder... builders) { + Order order = new Order(); + order.setCustomer( customer ); + Stream.of(builders).forEach( b -> order.addTrade( b.trade ) ); + return order; + } + + public static TradeBuilder buy(Consumer consumer) { + return buildTrade( consumer, Trade.Type.BUY ); + } + + public static TradeBuilder sell(Consumer consumer) { + return buildTrade( consumer, Trade.Type.SELL ); + } + + private static TradeBuilder buildTrade( Consumer consumer, Trade.Type buy ) { + TradeBuilder builder = new TradeBuilder(); + builder.trade.setType( buy ); + consumer.accept( builder ); + return builder; + } + + public static class TradeBuilder { + private Trade trade = new Trade(); + + public TradeBuilder quantity(int quantity) { + trade.setQuantity( quantity ); + return this; + } + + public TradeBuilder at(double price) { + trade.setPrice( price ); + return this; + } + + public StockBuilder stock(String symbol) { + return new StockBuilder(this, trade, symbol); + } + } + + public static class StockBuilder { + private final TradeBuilder builder; + private final Trade trade; + private final Stock stock = new Stock(); + + private StockBuilder(TradeBuilder builder, Trade trade, String symbol) { + this.builder = builder; + this.trade = trade; + stock.setSymbol( symbol ); + } + + public TradeBuilder on(String market) { + stock.setMarket( market ); + trade.setStock( stock ); + return builder; + } + } +} diff --git a/src/main/java/lambdasinaction/dsl/NestedFunctionOrderBuilder.java b/src/main/java/lambdasinaction/dsl/NestedFunctionOrderBuilder.java new file mode 100644 index 00000000..b9daaac9 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/NestedFunctionOrderBuilder.java @@ -0,0 +1,64 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl; + +import lambdasinaction.dsl.model.Order; +import lambdasinaction.dsl.model.Stock; +import lambdasinaction.dsl.model.Trade; + +import java.util.stream.Stream; + +public class NestedFunctionOrderBuilder { + + public static Order order(String customer, Trade... trades) { + Order order = new Order(); + order.setCustomer( customer ); + Stream.of(trades).forEach( order::addTrade ); + return order; + } + + public static Trade buy(int quantity, Stock stock, double price) { + return buildTrade( stock, price, Trade.Type.BUY ); + } + + public static Trade sell(int quantity, Stock stock, double price) { + return buildTrade( stock, price, Trade.Type.SELL ); + } + + private static Trade buildTrade( Stock stock, double price, Trade.Type buy ) { + Trade trade = new Trade(); + trade.setType( buy ); + trade.setStock( stock ); + trade.setPrice( price ); + return trade; + } + + public static double at(double price) { + return price; + } + + public static Stock stock(String symbol, String market) { + Stock stock = new Stock(); + stock.setSymbol( symbol ); + stock.setMarket( market ); + return stock; + } + + public static String on(String market) { + return market; + } +} diff --git a/src/main/java/lambdasinaction/dsl/TaxCalculator.java b/src/main/java/lambdasinaction/dsl/TaxCalculator.java new file mode 100644 index 00000000..9ef38cef --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/TaxCalculator.java @@ -0,0 +1,81 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl; + +import lambdasinaction.dsl.model.Order; +import lambdasinaction.dsl.model.Tax; + +import java.util.function.Function; + +public class TaxCalculator { + + public static double calculate( Order order, boolean useRegional, boolean useGeneral, boolean useSurcharge ) { + double value = order.getValue(); + if (useRegional) value = Tax.regional(value); + if (useGeneral) value = Tax.general(value); + if (useSurcharge) value = Tax.surcharge(value); + return value; + } + + private boolean useRegional; + private boolean useGeneral; + private boolean useSurcharge; + + public TaxCalculator withTaxRegional() { + useRegional = true; + return this; + } + + public TaxCalculator withTaxGeneral() { + useGeneral= true; + return this; + } + + public TaxCalculator withTaxSurcharge() { + useSurcharge = true; + return this; + } + + public double calculate(Order order) { + return calculate( order, useRegional, useGeneral, useSurcharge ); + } + + public Function taxFuncion = Function.identity(); + + public TaxCalculator with(Function f) { + taxFuncion.andThen( f ); + return this; + } + + public double calculateF(Order order) { + return taxFuncion.apply( order.getValue() ); + } + + public static void main(String[] args) { + Order order = new Order(); + + double value = TaxCalculator.calculate( order, true, false, true ); + + value = new TaxCalculator().withTaxRegional() + .withTaxSurcharge() + .calculate( order ); + + value = new TaxCalculator().with(Tax::regional) + .with(Tax::surcharge) + .calculate( order ); + } +} diff --git a/src/main/java/lambdasinaction/dsl/model/Order.java b/src/main/java/lambdasinaction/dsl/model/Order.java new file mode 100644 index 00000000..21c06747 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/model/Order.java @@ -0,0 +1,43 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl.model; + +import java.util.ArrayList; +import java.util.List; + +public class Order { + + private String customer; + + private List trades = new ArrayList<>(); + + public void addTrade( Trade trade ) { + trades.add( trade ); + } + + public String getCustomer() { + return customer; + } + + public void setCustomer( String customer ) { + this.customer = customer; + } + + public double getValue() { + return trades.stream().mapToDouble( Trade::getValue ).sum(); + } +} \ No newline at end of file diff --git a/src/main/java/lambdasinaction/dsl/model/Stock.java b/src/main/java/lambdasinaction/dsl/model/Stock.java new file mode 100644 index 00000000..1e0302e2 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/model/Stock.java @@ -0,0 +1,40 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl.model; + +public class Stock { + + private String symbol; + + private String market; + + public String getSymbol() { + return symbol; + } + + public void setSymbol( String symbol ) { + this.symbol = symbol; + } + + public String getMarket() { + return market; + } + + public void setMarket( String market ) { + this.market = market; + } +} diff --git a/src/main/java/lambdasinaction/dsl/model/Tax.java b/src/main/java/lambdasinaction/dsl/model/Tax.java new file mode 100644 index 00000000..d2d6bf22 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/model/Tax.java @@ -0,0 +1,31 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl.model; + +public class Tax { + public static double regional(double value) { + return value * 1.1; + } + + public static double general(double value) { + return value * 1.3; + } + + public static double surcharge(double value) { + return value * 1.05; + } +} diff --git a/src/main/java/lambdasinaction/dsl/model/Trade.java b/src/main/java/lambdasinaction/dsl/model/Trade.java new file mode 100644 index 00000000..c8f35813 --- /dev/null +++ b/src/main/java/lambdasinaction/dsl/model/Trade.java @@ -0,0 +1,66 @@ +/* + * Copyright 2005 JBoss Inc + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package lambdasinaction.dsl.model; + +public class Trade { + + public enum Type { BUY, SELL } + + private Type type; + + private Stock stock; + + private int quantity; + + private double price; + + public Type getType() { + return type; + } + + public void setType( Type type ) { + this.type = type; + } + + public int getQuantity() { + return quantity; + } + + public void setQuantity( int quantity ) { + this.quantity = quantity; + } + + public double getPrice() { + return price; + } + + public void setPrice( double price ) { + this.price = price; + } + + public Stock getStock() { + return stock; + } + + public void setStock( Stock stock ) { + this.stock = stock; + } + + public double getValue() { + return quantity * price; + } +} From 5ff395e4987028a114f2345acc11cee36c2296d5 Mon Sep 17 00:00:00 2001 From: Mario Fusco Date: Wed, 23 Mar 2016 19:23:11 +0100 Subject: [PATCH 10/12] dsl chapter --- src/main/java/lambdasinaction/dsl/Grouping.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/lambdasinaction/dsl/Grouping.java b/src/main/java/lambdasinaction/dsl/Grouping.java index 698764d5..b1472cf0 100644 --- a/src/main/java/lambdasinaction/dsl/Grouping.java +++ b/src/main/java/lambdasinaction/dsl/Grouping.java @@ -16,7 +16,7 @@ package lambdasinaction.dsl; -import lambdasinaction.chap5.Dish; +import lambdasinaction.chap6.Dish; import java.util.List; import java.util.Map; @@ -24,7 +24,7 @@ import java.util.stream.Collector; import static java.util.stream.Collectors.groupingBy; -import static lambdasinaction.chap5.Dish.menu; +import static lambdasinaction.chap6.Dish.menu; import static lambdasinaction.dsl.Grouping.GroupingBuilder.groupOn; public class Grouping { From 4cd6b4d4de144e073758114b55493d8c3ebef852 Mon Sep 17 00:00:00 2001 From: Jorge Cabrera Date: Sat, 6 Aug 2016 11:31:03 -0700 Subject: [PATCH 11/12] Filter to return only low calorie dishes --- src/main/java/lambdasinaction/chap4/StreamBasic.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/lambdasinaction/chap4/StreamBasic.java b/src/main/java/lambdasinaction/chap4/StreamBasic.java index 9beea005..19a8c176 100644 --- a/src/main/java/lambdasinaction/chap4/StreamBasic.java +++ b/src/main/java/lambdasinaction/chap4/StreamBasic.java @@ -24,7 +24,7 @@ public static void main(String...args){ public static List getLowCaloricDishesNamesInJava7(List dishes){ List lowCaloricDishes = new ArrayList<>(); for(Dish d: dishes){ - if(d.getCalories() > 400){ + if(d.getCalories() < 400){ lowCaloricDishes.add(d); } } @@ -42,7 +42,7 @@ public int compare(Dish d1, Dish d2){ public static List getLowCaloricDishesNamesInJava8(List dishes){ return dishes.stream() - .filter(d -> d.getCalories() > 400) + .filter(d -> d.getCalories() < 400) .sorted(comparing(Dish::getCalories)) .map(Dish::getName) .collect(toList()); From 4786c46a24e2f7d0a749d34d585bb2c1d9f64c53 Mon Sep 17 00:00:00 2001 From: Mario Fusco Date: Fri, 24 Feb 2017 08:52:33 +0100 Subject: [PATCH 12/12] changes for 2nd edition --- pom.xml | 35 ++++++++++- .../chap10/OperationsWithOptional.java | 7 +++ .../lambdasinaction/chap10/OptionalMain.java | 11 ++++ src/main/java/lambdasinaction/chap6/Dish.java | 34 +++++++--- .../java/lambdasinaction/chap6/Grouping.java | 17 +++++ .../chap6/PartitionPrimeNumbers.java | 8 +-- .../chap7/ParallelStreamBenchmark.java | 62 +++++++++++++++++++ 7 files changed, 158 insertions(+), 16 deletions(-) create mode 100644 src/main/java/lambdasinaction/chap7/ParallelStreamBenchmark.java diff --git a/pom.xml b/pom.xml index 32ca0b3e..10e5035e 100644 --- a/pom.xml +++ b/pom.xml @@ -13,6 +13,16 @@ + + org.openjdk.jmh + jmh-core + 1.17.4 + + + org.openjdk.jmh + jmh-generator-annprocess + 1.17.4 + junit junit @@ -27,11 +37,30 @@ maven-compiler-plugin 3.1 - 1.8 - 1.8 + 1.9 + 1.9 + + org.apache.maven.plugins + maven-shade-plugin + + + package + + shade + + + benchmarks + + + org.openjdk.jmh.Main + + + + + + - \ No newline at end of file diff --git a/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java b/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java index de588759..d2940969 100644 --- a/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java +++ b/src/main/java/lambdasinaction/chap10/OperationsWithOptional.java @@ -10,6 +10,13 @@ public class OperationsWithOptional { public static void main(String... args) { System.out.println(max(of(3), of(5))); System.out.println(max(empty(), of(5))); + + Optional opt1 = of(5); + Optional opt2 = opt1.or(() -> of(4)); + + System.out.println( + of(5).or(() -> of(4)) + ); } public static final Optional max(Optional i, Optional j) { diff --git a/src/main/java/lambdasinaction/chap10/OptionalMain.java b/src/main/java/lambdasinaction/chap10/OptionalMain.java index 1826cb4a..dcd97792 100644 --- a/src/main/java/lambdasinaction/chap10/OptionalMain.java +++ b/src/main/java/lambdasinaction/chap10/OptionalMain.java @@ -2,6 +2,8 @@ import java.util.*; +import static java.util.stream.Collectors.toSet; + public class OptionalMain { public String getCarInsuranceName(Optional person) { @@ -10,4 +12,13 @@ public String getCarInsuranceName(Optional person) { .map(Insurance::getName) .orElse("Unknown"); } + + public Set getCarInsuranceNames(List persons) { + return persons.stream() + .map(Person::getCar) + .map(optCar -> optCar.flatMap(Car::getInsurance)) + .map(optInsurance -> optInsurance.map(Insurance::getName)) + .flatMap(Optional::stream) + .collect(toSet()); + } } diff --git a/src/main/java/lambdasinaction/chap6/Dish.java b/src/main/java/lambdasinaction/chap6/Dish.java index a353f1bc..adba6e93 100644 --- a/src/main/java/lambdasinaction/chap6/Dish.java +++ b/src/main/java/lambdasinaction/chap6/Dish.java @@ -2,6 +2,8 @@ import java.util.*; +import static java.util.Arrays.asList; + public class Dish { private final String name; @@ -40,13 +42,27 @@ public String toString() { } public static final List menu = - Arrays.asList( new Dish("pork", false, 800, Dish.Type.MEAT), - new Dish("beef", false, 700, Dish.Type.MEAT), - new Dish("chicken", false, 400, Dish.Type.MEAT), - new Dish("french fries", true, 530, Dish.Type.OTHER), - new Dish("rice", true, 350, Dish.Type.OTHER), - new Dish("season fruit", true, 120, Dish.Type.OTHER), - new Dish("pizza", true, 550, Dish.Type.OTHER), - new Dish("prawns", false, 400, Dish.Type.FISH), - new Dish("salmon", false, 450, Dish.Type.FISH)); + asList( new Dish("pork", false, 800, Dish.Type.MEAT), + new Dish("beef", false, 700, Dish.Type.MEAT), + new Dish("chicken", false, 400, Dish.Type.MEAT), + new Dish("french fries", true, 530, Dish.Type.OTHER), + new Dish("rice", true, 350, Dish.Type.OTHER), + new Dish("season fruit", true, 120, Dish.Type.OTHER), + new Dish("pizza", true, 550, Dish.Type.OTHER), + new Dish("prawns", false, 400, Dish.Type.FISH), + new Dish("salmon", false, 450, Dish.Type.FISH)); + + public static final Map> dishTags = new HashMap<>(); + + static { + dishTags.put("pork", asList("greasy", "salty")); + dishTags.put("beef", asList("salty", "roasted")); + dishTags.put("chicken", asList("fried", "crisp")); + dishTags.put("french fries", asList("greasy", "fried")); + dishTags.put("rice", asList("light", "natural")); + dishTags.put("season fruit", asList("fresh", "natural")); + dishTags.put("pizza", asList("tasty", "salty")); + dishTags.put("prawns", asList("tasty", "roasted")); + dishTags.put("salmon", asList("delicious", "fresh")); + } } \ No newline at end of file diff --git a/src/main/java/lambdasinaction/chap6/Grouping.java b/src/main/java/lambdasinaction/chap6/Grouping.java index bedb3470..9105cc80 100644 --- a/src/main/java/lambdasinaction/chap6/Grouping.java +++ b/src/main/java/lambdasinaction/chap6/Grouping.java @@ -3,6 +3,7 @@ import java.util.*; import static java.util.stream.Collectors.*; +import static lambdasinaction.chap6.Dish.dishTags; import static lambdasinaction.chap6.Dish.menu; public class Grouping { @@ -11,6 +12,9 @@ enum CaloricLevel { DIET, NORMAL, FAT }; public static void main(String ... args) { System.out.println("Dishes grouped by type: " + groupDishesByType()); + System.out.println("Dish names grouped by type: " + groupDishNamesByType()); + System.out.println("Dish tags grouped by type: " + groupDishTagsByType()); + System.out.println("Caloric dishes grouped by type: " + groupCaloricDishesByType()); System.out.println("Dishes grouped by caloric level: " + groupDishesByCaloricLevel()); System.out.println("Dishes grouped by type and caloric level: " + groupDishedByTypeAndCaloricLevel()); System.out.println("Count dishes in groups: " + countDishesInGroups()); @@ -24,6 +28,19 @@ private static Map> groupDishesByType() { return menu.stream().collect(groupingBy(Dish::getType)); } + private static Map> groupDishNamesByType() { + return menu.stream().collect(groupingBy(Dish::getType, mapping(Dish::getName, toList()))); + } + + private static Map> groupDishTagsByType() { + return menu.stream().collect(groupingBy(Dish::getType, flatMapping(dish -> dishTags.get( dish.getName() ).stream(), toSet()))); + } + + private static Map> groupCaloricDishesByType() { +// return menu.stream().filter(dish -> dish.getCalories() > 500).collect(groupingBy(Dish::getType)); + return menu.stream().collect(groupingBy(Dish::getType, filtering(dish -> dish.getCalories() > 500, toList()))); + } + private static Map> groupDishesByCaloricLevel() { return menu.stream().collect( groupingBy(dish -> { diff --git a/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java b/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java index 5122a6a3..69d7c4ca 100644 --- a/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java +++ b/src/main/java/lambdasinaction/chap6/PartitionPrimeNumbers.java @@ -32,10 +32,10 @@ public static Map> partitionPrimesWithCustomCollector(int public static boolean isPrime(List primes, Integer candidate) { double candidateRoot = Math.sqrt((double) candidate); - //return primes.stream().filter(p -> p < candidateRoot).noneMatch(p -> candidate % p == 0); - return takeWhile(primes, i -> i <= candidateRoot).stream().noneMatch(i -> candidate % i == 0); + //return takeWhile(primes, i -> i <= candidateRoot).stream().noneMatch(i -> candidate % i == 0); + return primes.stream().takeWhile(i -> i <= candidateRoot).noneMatch(i -> candidate % i == 0); } - +/* public static List takeWhile(List list, Predicate p) { int i = 0; for (A item : list) { @@ -46,7 +46,7 @@ public static List takeWhile(List list, Predicate p) { } return list; } - +*/ public static class PrimeNumbersCollector implements Collector>, Map>> { diff --git a/src/main/java/lambdasinaction/chap7/ParallelStreamBenchmark.java b/src/main/java/lambdasinaction/chap7/ParallelStreamBenchmark.java new file mode 100644 index 00000000..cdd16aca --- /dev/null +++ b/src/main/java/lambdasinaction/chap7/ParallelStreamBenchmark.java @@ -0,0 +1,62 @@ +package lambdasinaction.chap7; + +import java.util.concurrent.TimeUnit; +import java.util.stream.LongStream; +import java.util.stream.Stream; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Level; +import org.openjdk.jmh.annotations.Measurement; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.State; +import org.openjdk.jmh.annotations.TearDown; +import org.openjdk.jmh.annotations.Warmup; + +@State(Scope.Thread) +@BenchmarkMode(Mode.AverageTime) +@OutputTimeUnit(TimeUnit.MILLISECONDS) +@Fork(value=2, jvmArgs={"-Xms4G", "-Xmx4G"}) +@Measurement(iterations=2) +@Warmup(iterations=3) +public class ParallelStreamBenchmark { + + private static final long N = 10_000_000L; + + @Benchmark + public long iterativeSum() { + long result = 0; + for (long i = 1L; i <= N; i++) { + result += i; + } + return result; + } + + @Benchmark + public long sequentialSum() { + return Stream.iterate( 1L, i -> i + 1 ).limit(N).reduce( 0L, Long::sum ); + } + + @Benchmark + public long parallelSum() { + return Stream.iterate(1L, i -> i + 1).limit(N).parallel().reduce( 0L, Long::sum); + } + + @Benchmark + public long rangedSum() { + return LongStream.rangeClosed( 1, N ).reduce( 0L, Long::sum ); + } + + @Benchmark + public long parallelRangedSum() { + return LongStream.rangeClosed(1, N).parallel().reduce( 0L, Long::sum); + } + + @TearDown(Level.Invocation) + public void tearDown() { + System.gc(); + } +}