Cleaned up Chapter 5 (Generics). Some examples were missing, some extraneous examples were present, and some page numbers were wrong.

Author: jbloch

src/effectivejava/chapter5/item28/Chooser.java

@@ -6,7 +6,7 @@
 import java.util.Random;
 import java.util.concurrent.ThreadLocalRandom;
 
-// List-based Chooser - typesafe (Page 120)
+// List-based Chooser - typesafe (Page 129)
 public class Chooser<T> {
     private final List<T> choiceList;
 
@@ -18,4 +18,15 @@ public T choose() {
         Random rnd = ThreadLocalRandom.current();
         return choiceList.get(rnd.nextInt(choiceList.size()));
     }
+
+    public static void main(String[] args) {
+        List<Integer> intList = List.of(1, 2, 3, 4, 5, 6);
+
+        Chooser<Integer> chooser = new Chooser<>(intList);
+
+        for (int i = 0; i < 10; i++) {
+            Number choice = chooser.choose();
+            System.out.println(choice);
+        }
+    }
 }

src/effectivejava/chapter5/item29/technqiue1/Stack.java

@@ -3,7 +3,7 @@
 
 import java.util.Arrays;
 
-// Generic stack using E[] - Pages 130-133
+// Generic stack using E[] (Pages 130-3)
 public class Stack<E> {
     private E[] elements;
     private int size = 0;

src/effectivejava/chapter5/item29/technqiue2/Stack.java

@@ -3,7 +3,7 @@
 import java.util.Arrays;
 import effectivejava.chapter5.item29.EmptyStackException;
 
-// Generic stack using Object[] - Pages 130-133
+// Generic stack using Object[] (Pages 130-3)
 public class Stack<E> {
     private Object[] elements;
     private int size = 0;

src/effectivejava/chapter5/item30/GenericSingletonFactory.java

@@ -1,10 +1,8 @@
 package effectivejava.chapter5.item30;
 
-// Generic singleton factory staticfactory - Pages 131-132
-
 import java.util.function.UnaryOperator;
 
-// Generic singleton factory pattern (Page 136)
+// Generic singleton factory pattern (Page 136-7)
 public class GenericSingletonFactory {
     // Generic singleton factory pattern
     private static UnaryOperator<Object> IDENTITY_FN = (t) -> t;

src/effectivejava/chapter5/item30/RecursiveTypeBound.java

@@ -1,7 +1,7 @@
 package effectivejava.chapter5.item30;
 import java.util.*;
 
-// Using a recursive type bound to express mutual comparability - Pages 136-137
+// Using a recursive type bound to express mutual comparability (Pages 137-8)
 public class RecursiveTypeBound {
     // Returns max value in a collection - uses recursive type bound
     public static <E extends Comparable<E>> E max(Collection<E> c) {

src/effectivejava/chapter5/item30/Union.java

@@ -1,7 +1,7 @@
 package effectivejava.chapter5.item30;
 import java.util.*;
 
-// Generic union method and program to exercise it - pages 135-6
+// Generic union method and program to exercise it  (Pages 135-6)
 public class Union {
 
     // Generic method

src/effectivejava/chapter5/item32/Chooser.java renamed to src/effectivejava/chapter5/item31/Chooser.java

@@ -1,10 +1,11 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
 import java.util.Random;
 
+// Wildcard type for parameter that serves as an T producer (page 141)
 public class Chooser<T> {
     private final List<T> choiceList;
     private final Random rnd = new Random();

src/effectivejava/chapter5/item32/EmptyStackException.java renamed to src/effectivejava/chapter5/item31/EmptyStackException.java

@@ -1,4 +1,4 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 
 public class EmptyStackException extends RuntimeException {
 }

src/effectivejava/chapter5/item32/RecursiveTypeBound.java renamed to src/effectivejava/chapter5/item31/RecursiveTypeBound.java

@@ -1,7 +1,7 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 import java.util.*;
 
-// Using a recursive type bound with wildcards - Page 138-139
+// Using a recursive type bound with wildcards (Page 143)
 public class RecursiveTypeBound {
     public static <E extends Comparable<? super E>> E max(
         List<? extends E> list) {

src/effectivejava/chapter5/item32/Stack.java renamed to src/effectivejava/chapter5/item31/Stack.java

@@ -1,7 +1,7 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 import java.util.*;
 
-// Generic stack with bulk methods using wildcard types - Pages 138-140
+// Generic stack with bulk methods using wildcard types (Pages 139-41)
 public class Stack<E> {
     private E[] elements;
     private int size = 0;
@@ -63,11 +63,11 @@ public void popAll(Collection<? super E> dst) {
 
     // Little program to exercise our generic Stack
     public static void main(String[] args) {
-        Stack<Number> numberStack = new Stack<Number>();
+        Stack<Number> numberStack = new Stack<>();
         Iterable<Integer> integers = Arrays.asList(3, 1, 4, 1, 5, 9);
         numberStack.pushAll(integers);
 
-        Collection<Object> objects = new ArrayList<Object>();
+        Collection<Object> objects = new ArrayList<>();
         numberStack.popAll(objects);
 
         System.out.println(objects);

src/effectivejava/chapter5/item32/Swap.java renamed to src/effectivejava/chapter5/item31/Swap.java

@@ -1,13 +1,13 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 import java.util.*;
 
-// Private helper staticfactory for wildcard capture - Pages 139-140
+// Private helper method for wildcard capture (Page 145)
 public class Swap {
     public static void swap(List<?> list, int i, int j) {
         swapHelper(list, i, j);
     }
 
-    // Private helper staticfactory for wildcard capture
+    // Private helper method for wildcard capture
     private static <E> void swapHelper(List<E> list, int i, int j) {
         list.set(i, list.set(j, list.get(i)));
     }

src/effectivejava/chapter5/item32/Union.java renamed to src/effectivejava/chapter5/item31/Union.java

@@ -1,9 +1,8 @@
-package effectivejava.chapter5.item32;
+package effectivejava.chapter5.item31;
 import java.util.*;
 
-// Generic union staticfactory with wildcard types - Pages 137-138
+// Generic union method with wildcard types for enhanced flexibility (Pages 142-3)
 public class Union {
-
     public static <E> Set<E> union(Set<? extends E> s1,
                                    Set<? extends E> s2) {
         Set<E> result = new HashSet<E>(s1);
@@ -25,6 +24,9 @@ public static void main(String[] args) {
 
         Set<Number> numbers = union(integers, doubles);
 
+//      // Explicit type parameter - required prior to Java 8
+//      Set<Number> numbers = Union.<Number>union(integers, doubles);
+
         System.out.println(numbers);
     }
 }

src/effectivejava/chapter5/item32/Dangerous.java

@@ -0,0 +1,18 @@
+package effectivejava.chapter5.item32;
+
+import java.util.List;
+
+// It is unsafe to store a value in a generic varargs array parameter (Page 146)
+public class Dangerous {
+    // Mixing generics and varargs can violate type safety!
+    static void dangerous(List<String>... stringLists) {
+        List<Integer> intList = List.of(42);
+        Object[] objects = stringLists;
+        objects[0] = intList; // Heap pollution
+        String s = stringLists[0].get(0); // ClassCastException
+    }
+
+    public static void main(String[] args) {
+        dangerous(List.of("There be dragons!"));
+    }
+}

src/effectivejava/chapter5/item32/FlattenWithList.java

@@ -0,0 +1,20 @@
+package effectivejava.chapter5.item32;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// List as a typesafe alternative to a generic varargs parameter (page 149)
+public class FlattenWithList {
+    static <T> List<T> flatten(List<List<? extends T>> lists) {
+        List<T> result = new ArrayList<>();
+        for (List<? extends T> list : lists)
+            result.addAll(list);
+        return result;
+    }
+
+    public static void main(String[] args) {
+        List<Integer> flatList = flatten(List.of(
+                List.of(1, 2), List.of(3, 4, 5), List.of(6,7)));
+        System.out.println(flatList);
+    }
+}

src/effectivejava/chapter5/item32/FlattenWithVarargs.java

@@ -0,0 +1,21 @@
+package effectivejava.chapter5.item32;
+
+import java.util.ArrayList;
+import java.util.List;
+
+// Safe method with a generic varargs parameter (page 149)
+public class FlattenWithVarargs {
+    @SafeVarargs
+    static <T> List<T> flatten(List<? extends T>... lists) {
+        List<T> result = new ArrayList<>();
+        for (List<? extends T> list : lists)
+            result.addAll(list);
+        return result;
+    }
+
+    public static void main(String[] args) {
+        List<Integer> flatList = flatten(
+                List.of(1, 2), List.of(3, 4, 5), List.of(6,7));
+        System.out.println(flatList);
+    }
+}

src/effectivejava/chapter5/item32/Function.java

@@ -0,0 +1,26 @@
+package effectivejava.chapter5.item32;
+
+import java.util.Arrays;
+import java.util.concurrent.ThreadLocalRandom;
+
+// Subtle heap pollution (Pages 147-8)
+public class PickTwo {
+    // UNSAFE - Exposes a reference to its generic parameter array!
+    static <T> T[] toArray(T... args) {
+        return args;
+    }
+
+    static <T> T[] pickTwo(T a, T b, T c) {
+        switch(ThreadLocalRandom.current().nextInt(3)) {
+            case 0: return toArray(a, b);
+            case 1: return toArray(a, c);
+            case 2: return toArray(b, c);
+        }
+        throw new AssertionError(); // Can't get here
+    }
+
+    public static void main(String[] args) {
+        String[] attributes = pickTwo("Good", "Fast", "Cheap");
+        System.out.println(Arrays.toString(attributes));
+    }
+}

src/effectivejava/chapter5/item32/PickTwo.java

@@ -0,0 +1,22 @@
+package effectivejava.chapter5.item32;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ThreadLocalRandom;
+
+// Safe version of PickTwo using lists instead of arrays (Page 150)
+public class SafePickTwo {
+    static <T> List<T> pickTwo(T a, T b, T c) {
+        switch(ThreadLocalRandom.current().nextInt(3)) {
+            case 0: return List.of(a, b);
+            case 1: return List.of(a, c);
+            case 2: return List.of(b, c);
+        }
+        throw new AssertionError();
+    }
+
+    public static void main(String[] args) {
+        List<String> attributes = pickTwo("Good", "Fast", "Cheap");
+        System.out.println(attributes);
+    }
+}

src/effectivejava/chapter5/item32/Reduction.java

@@ -1,34 +1,32 @@
 package effectivejava.chapter5.item33;
 import java.util.*;
 
-// Typesafe heterogeneous container - Pages 142-145
+// Typesafe heterogeneous container pattern (Pages 151-4)
 public class Favorites {
-    // Typesafe heterogeneous container pattern - implementation
-    private Map<Class<?>, Object> favorites = 
-        new HashMap<Class<?>, Object>();
+    private Map<Class<?>, Object> favorites = new HashMap<>();
 
     public <T> void putFavorite(Class<T> type, T instance) {
-        if (type == null)
-            throw new NullPointerException("LifeCycle is null");
-        favorites.put(type, instance);
+        favorites.put(Objects.requireNonNull(type), instance);
     }
 
     public <T> T getFavorite(Class<T> type) {
         return type.cast(favorites.get(type));
     }
 
+//    // Achieving runtime type safety with a dynamic cast
+//    public <T> void putFavorite(Class<T> type, T instance) {
+//        favorites.put(Objects.requireNonNull(type), type.cast(instance));
+//    }
 
-    // Typesafe heterogeneous container pattern - client
     public static void main(String[] args) {
         Favorites f = new Favorites();
         f.putFavorite(String.class, "Java");
         f.putFavorite(Integer.class, 0xcafebabe);
         f.putFavorite(Class.class, Favorites.class);
-
         String favoriteString = f.getFavorite(String.class);
         int favoriteInteger = f.getFavorite(Integer.class);
         Class<?> favoriteClass = f.getFavorite(Class.class);
         System.out.printf("%s %x %s%n", favoriteString,
-                          favoriteInteger, favoriteClass.getName());
+                favoriteInteger, favoriteClass.getName());
     }
 }

src/effectivejava/chapter5/item32/SafePickTwo.java

@@ -2,9 +2,8 @@
 import java.lang.annotation.*;
 import java.lang.reflect.*;
 
-// Use of asSubclass to safely cast to a bounded type token - Page 146
+// Use of asSubclass to safely cast to a bounded type token (Page 155)
 public class PrintAnnotation {
-    // Use of asSubclass to safely cast to a bounded type token
     static Annotation getAnnotation(AnnotatedElement element,
                                     String annotationTypeName) {
         Class<?> annotationType = null; // Unbounded type token
@@ -14,7 +13,7 @@ static Annotation getAnnotation(AnnotatedElement element,
             throw new IllegalArgumentException(ex);
         }
         return element.getAnnotation(
-            annotationType.asSubclass(Annotation.class));
+                annotationType.asSubclass(Annotation.class));
     }
 
     // Test program to print named annotation of named class