Clean up code examples from Chapter 7 (Lambdas and Streams)

Author: jbloch

src/effectivejava/chapter6/item34/Operation.java

@@ -4,7 +4,7 @@
 
 import static java.util.stream.Collectors.toMap;
 
-// Enum type with constant-specific class bodies and data (Page 163-4)
+// Enum type with constant-specific class bodies and data (Pages 163-4)
 public enum Operation {
     PLUS("+") {
         public double apply(double x, double y) { return x + y; }

src/effectivejava/chapter7/item42/Operation.java

@@ -2,7 +2,7 @@
 
 import java.util.function.DoubleBinaryOperator;
 
-// Enum with function object fields & constant-specific behavior
+// Enum with function object fields & constant-specific behavior (Page 195)
 public enum Operation {
     PLUS  ("+", (x, y) -> x + y),
     MINUS ("-", (x, y) -> x - y),
@@ -22,4 +22,13 @@ public enum Operation {
     public double apply(double x, double y) {
         return op.applyAsDouble(x, y);
     }
+
+    // Main method from Item 34 (Page 163)
+    public static void main(String[] args) {
+        double x = Double.parseDouble(args[0]);
+        double y = Double.parseDouble(args[1]);
+        for (Operation op : Operation.values())
+            System.out.printf("%f %s %f = %f%n",
+                    x, op, y, op.apply(x, y));
+    }
 }

src/effectivejava/chapter7/item42/SortFourWays.java

@@ -8,11 +8,12 @@
 
 import static java.util.Comparator.comparingInt;
 
+// Sorting with function objects (Pages 193-4)
 public class SortFourWays {
     public static void main(String[] args) {
         List<String> words = Arrays.asList(args);
 
-        // Anonymous class instance as a function object - obsolete!
+        // Anonymous class instance as a function object - obsolete! (Page 193)
         Collections.sort(words, new Comparator<String>() {
             public int compare(String s1, String s2) {
                 return Integer.compare(s1.length(), s2.length());
@@ -21,16 +22,18 @@ public int compare(String s1, String s2) {
         System.out.println(words);
         Collections.shuffle(words);
 
-        // Lambda expression as function object (replaces anonymous class)
+        // Lambda expression as function object (replaces anonymous class) (Page 194)
         Collections.sort(words,
                 (s1, s2) -> Integer.compare(s1.length(), s2.length()));
         System.out.println(words);
         Collections.shuffle(words);
 
+        // Comparator construction method (with method reference) in place of lambda (Page 194)
         Collections.sort(words, comparingInt(String::length));
         System.out.println(words);
         Collections.shuffle(words);
 
+        // Default method List.sort in conjunction with comparator construction method (Page 194)
         words.sort(comparingInt(String::length));
         System.out.println(words);
     }

src/effectivejava/chapter7/item43/Freq.java

@@ -3,15 +3,19 @@
 import java.util.Map;
 import java.util.TreeMap;
 
-// p. 197
+// Frequency table implemented with map.merge, using lambda and method reference (Page 197)
 public class Freq {
     public static void main(String[] args) {
         Map<String, Integer> frequencyTable = new TreeMap<>();
-        for (String s : args) {
-//          map.merge(key, 1, (count, incr) -> count + incr);
-            frequencyTable.merge(s, 1, Integer::sum);
-        }
+        
+        for (String s : args)
+            frequencyTable.merge(s, 1, (count, incr) -> count + incr); // Lambda
+        System.out.println(frequencyTable);
 
+        frequencyTable.clear();
+        for (String s : args)
+            frequencyTable.merge(s, 1, Integer::sum); // Method reference
         System.out.println(frequencyTable);
+
     }
 }

src/effectivejava/chapter7/item45/Card.java

@@ -5,10 +5,11 @@
 import java.util.stream.Stream;
 import static java.util.stream.Collectors.*;
 
+// Generating the Cartesian product of two lists using iteration and streams (Page 209)
 public class Card {
     public enum Suit { SPADE, HEART, DIAMOND, CLUB }
     public enum Rank { ACE, DEUCE, THREE, FOUR, FIVE, SIX, SEVEN,
-        EIGHT, NINE, TEN, JACK, KING, QUEEN }
+                       EIGHT, NINE, TEN, JACK, QUEEN, KING }
 
     private final Suit suit;
     private final Rank rank;

src/effectivejava/chapter7/item45/CharStream.java

@@ -0,0 +1,14 @@
+package effectivejava.chapter7.item45;
+
+// Refrain from using streams to process char values (Page 206)
+public class CharStream {
+    public static void main(String[] args) {
+        // Does not produce the expected result
+        "Hello world!".chars().forEach(System.out::print);
+        System.out.println();
+
+        // Fixes the problem
+        "Hello world!".chars().forEach(x -> System.out.print((char) x));
+        System.out.println();
+    }
+}

src/effectivejava/chapter7/item45/MersennePrimes.java

@@ -5,7 +5,7 @@
 
 import static java.math.BigInteger.*;
 
-// P. 208
+// Generating the first twent Mersenne primes using streams (Page 208)
 public class MersennePrimes {
     static Stream<BigInteger> primes() {
         return Stream.iterate(TWO, BigInteger::nextProbablePrime);

src/effectivejava/chapter7/item45/anagrams/HybridAnagrams.java

@@ -9,7 +9,7 @@
 
 import static java.util.stream.Collectors.groupingBy;
 
-// Tasteful use of streams enhances clarity and conciseness
+// Tasteful use of streams enhances clarity and conciseness (Page 205)
 public class HybridAnagrams {
     public static void main(String[] args) throws IOException {
         Path dictionary = Paths.get(args[0]);

src/effectivejava/chapter7/item45/anagrams/IterativeAnagrams.java

@@ -4,7 +4,7 @@
 import java.io.IOException;
 import java.util.*;
 
-// Prints all large anagram groups in a dictionary iteratively
+// Prints all large anagram groups in a dictionary iteratively (Page 204)
 public class IterativeAnagrams {
     public static void main(String[] args) throws IOException {
         File dictionary = new File(args[0]);

src/effectivejava/chapter7/item45/anagrams/StreamAnagrams.java

@@ -8,7 +8,7 @@
 
 import static java.util.stream.Collectors.groupingBy;
 
-// Overuse of streams - don't do this! - (page 205)
+// Overuse of streams - don't do this! (page 205)
 public class StreamAnagrams {
     public static void main(String[] args) throws IOException {
         Path dictionary = Paths.get(args[0]);

src/effectivejava/chapter7/item45/Freq.java renamed to src/effectivejava/chapter7/item46/Freq.java

@@ -1,4 +1,4 @@
-package effectivejava.chapter7.item45;
+package effectivejava.chapter7.item46;
 
 import java.io.File;
 import java.io.FileNotFoundException;
@@ -9,20 +9,20 @@
 import static java.util.stream.Collectors.*;
 import static java.util.stream.Collectors.*;
 
-// Page 210, 211
+// Frequency table examples showing improper and proper use of stream (Page 210-11)
 public class Freq {
     public static void main(String[] args) throws FileNotFoundException {
         File file = new File(args[0]);
 
-        // Uses the streams API but not the paradigm--Don't do this!
+//        // Uses the streams API but not the paradigm--Don't do this!
 //        Map<String, Long> freq = new HashMap<>();
 //        try (Stream<String> words = new Scanner(file).tokens()) {
 //            words.forEach(word -> {
 //                freq.merge(word.toLowerCase(), 1L, Long::sum);
 //            });
 //        }
 
-        // Proper use of streams to initialize a frequency table
+        // Proper use of streams to initialize a frequency table (
         Map<String, Long> freq;
         try (Stream<String> words = new Scanner(file).tokens()) {
             freq = words

src/effectivejava/chapter7/item47/Adapters.java

@@ -3,8 +3,9 @@
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
+// Adapters from stream to iterable and vice-versa (Page 216)
 public class Adapters {
-    // Adapter from  Stream<E> to Iterable<E>
+    // Adapter from  Stream<E> to Iterable<E> (
     public static <E> Iterable<E> iterableOf(Stream<E> stream) {
         return stream::iterator;
     }

src/effectivejava/chapter7/item47/PowerSet.java

@@ -3,6 +3,7 @@
 import java.util.*;
 
 public class PowerSet {
+    // Returns the power set of an input set as custom collection (Page 218)
     public static final <E> Collection<Set<E>> of(Set<E> s) {
         List<E> src = new ArrayList<>(s);
         if (src.size() > 30)

src/effectivejava/chapter7/item47/SubLists.java

@@ -4,32 +4,34 @@
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
-// Returns a stream of all the sublists of its input list (Pages 219-220)
+// Two ways to generate a stream of all the sublists of a list (Pages 219-20)
 public class SubLists {
-//    public static <E> Stream<List<E>> of(List<E> list) {
-//        return Stream.concat(Stream.of(Collections.emptyList()),
-//                prefixes(list).flatMap(SubLists::suffixes));
-//    }
-//
-//    private static <E> Stream<List<E>> prefixes(List<E> list) {
-//        return IntStream.rangeClosed(1, list.size())
-//                .mapToObj(end -> list.subList(0, end));
-//    }
-//
-//    private static <E> Stream<List<E>> suffixes(List<E> list) {
-//        return IntStream.range(0, list.size())
-//                .mapToObj(start -> list.subList(start, list.size()));
-//    }
-
-    // Returns a stream of all the sublists of its input list
+    // Returns a stream of all the sublists of its input list (Page 219)
     public static <E> Stream<List<E>> of(List<E> list) {
+        return Stream.concat(Stream.of(Collections.emptyList()),
+                prefixes(list).flatMap(SubLists::suffixes));
+    }
+
+    private static <E> Stream<List<E>> prefixes(List<E> list) {
+        return IntStream.rangeClosed(1, list.size())
+                .mapToObj(end -> list.subList(0, end));
+    }
+
+    private static <E> Stream<List<E>> suffixes(List<E> list) {
         return IntStream.range(0, list.size())
-                .mapToObj(start ->
-                        IntStream.rangeClosed(start + 1, list.size())
-                                .mapToObj(end -> list.subList(start, end)))
-                .flatMap(x -> x);
+                .mapToObj(start -> list.subList(start, list.size()));
     }
 
+//    // Returns a stream of all the sublists of its input list, excluding the empty list
+//    // This version is derived from the obvious iterative code (Page 220)
+//    public static <E> Stream<List<E>> of(List<E> list) {
+//        return IntStream.range(0, list.size())
+//                .mapToObj(start ->
+//                        IntStream.rangeClosed(start + 1, list.size())
+//                                .mapToObj(end -> list.subList(start, end)))
+//                .flatMap(x -> x);
+//    }
+
     public static void main(String[] args) {
         List<String> list = Arrays.asList(args);
         SubLists.of(list).forEach(System.out::println);

src/effectivejava/chapter7/item48/ParallelMersennePrimes.java

@@ -5,7 +5,7 @@
 
 import static java.math.BigInteger.*;
 
-// Parallel stream-based program to generate the first 20 Mersenne primes - HANGS!!!
+// Parallel stream-based program to generate the first 20 Mersenne primes - HANGS!!! (Page 222)
 public class ParallelMersennePrimes {
     public static void main(String[] args) {
         primes().map(p -> TWO.pow(p.intValueExact()).subtract(ONE))

src/effectivejava/chapter7/item48/ParallelPrimeCounting.java

@@ -4,7 +4,7 @@
 import java.util.stream.LongStream;
 
 public class ParallelPrimeCounting {
-    // Prime-counting stream pipeline - parallel version
+    // Prime-counting stream pipeline - parallel version (Page 225)
     static long pi(long n) {
         return LongStream.rangeClosed(2, n)
                 .parallel()