Initial commit of Effective Java, 3e source code, only eight months too late.

Author: jbloch

.gitignore

@@ -0,0 +1,65 @@
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio and WebStorm
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# I [jjb] added this to ignore emacs autosaves
+*~
+
+# User-specific stuff
+# .idea/**/workspace.xml
+# .idea/**/tasks.xml
+# .idea/**/usage.statistics.xml
+# .idea/**/dictionaries
+# .idea/**/shelf
+.idea
+
+# Sensitive or high-churn files
+# .idea/**/dataSources/
+# .idea/**/dataSources.ids
+# .idea/**/dataSources.local.xml
+# .idea/**/sqlDataSources.xml
+# .idea/**/dynamic.xml
+# .idea/**/uiDesigner.xml
+# .idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+# .idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+*.iml
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+# .idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+# .idea/httpRequests

src/effectivejava/chapter10/item74/IndexOutOfBoundsException.java

@@ -0,0 +1,27 @@
+package effectivejava.chapter10.item74;
+
+public class IndexOutOfBoundsException extends RuntimeException {
+    private final int lowerBound;
+    private final int upperBound;
+    private final int index;
+
+    /**
+     * Constructs an IndexOutOfBoundsException.
+     *
+     * @param lowerBound the lowest legal index value
+     * @param upperBound the highest legal index value plus one
+     * @param index      the actual index value
+     */
+    public IndexOutOfBoundsException(int lowerBound, int upperBound,
+                                     int index) {
+        // Generate a detail message that captures the failure
+        super(String.format(
+                "Lower bound: %d, Upper bound: %d, Index: %d",
+                lowerBound, upperBound, index));
+
+        // Save failure information for programmatic access
+        this.lowerBound = lowerBound;
+        this.upperBound = upperBound;
+        this.index = index;
+    }
+}

src/effectivejava/chapter11/item78/brokenstopthread/StopThread.java

@@ -0,0 +1,20 @@
+package effectivejava.chapter11.item78.brokenstopthread;
+import java.util.concurrent.*;
+
+// Broken! - How long would you expect this program to run?  (Page 312)
+public class StopThread {
+    private static boolean stopRequested;
+
+    public static void main(String[] args)
+            throws InterruptedException {
+        Thread backgroundThread = new Thread(() -> {
+            int i = 0;
+            while (!stopRequested)
+                i++;
+        });
+        backgroundThread.start();
+
+        TimeUnit.SECONDS.sleep(1);
+        stopRequested = true;
+    }
+}

src/effectivejava/chapter11/item78/fixedstopthread1/StopThread.java

@@ -0,0 +1,28 @@
+package effectivejava.chapter11.item78.fixedstopthread1;
+import java.util.concurrent.*;
+
+// Properly synchronized cooperative thread termination
+public class StopThread {
+    private static boolean stopRequested;
+
+    private static synchronized void requestStop() {
+        stopRequested = true;
+    }
+
+    private static synchronized boolean stopRequested() {
+        return stopRequested;
+    }
+
+    public static void main(String[] args)
+            throws InterruptedException {
+        Thread backgroundThread = new Thread(() -> {
+            int i = 0;
+            while (!stopRequested())
+                i++;
+        });
+        backgroundThread.start();
+
+        TimeUnit.SECONDS.sleep(1);
+        requestStop();
+    }
+}  

src/effectivejava/chapter11/item78/fixedstopthread2/StopThread.java

@@ -0,0 +1,20 @@
+package effectivejava.chapter11.item78.fixedstopthread2;
+import java.util.concurrent.*;
+
+// Cooperative thread termination with a volatile field
+public class StopThread {
+    private static volatile boolean stopRequested;
+
+    public static void main(String[] args)
+            throws InterruptedException {
+        Thread backgroundThread = new Thread(() -> {
+            int i = 0;
+            while (!stopRequested)
+                i++;
+        });
+        backgroundThread.start();
+
+        TimeUnit.SECONDS.sleep(1);
+        stopRequested = true;
+    }
+}

src/effectivejava/chapter11/item79/ForwardingSet.java

@@ -0,0 +1,30 @@
+package effectivejava.chapter11.item79;
+import java.util.*;
+
+// Reusable forwarding class   (Page XXX)
+public class ForwardingSet<E> implements Set<E> {
+    private final Set<E> s;
+    public ForwardingSet(Set<E> s) { this.s = s; }
+
+    public void clear()               { s.clear();            }
+    public boolean contains(Object o) { return s.contains(o); }
+    public boolean isEmpty()          { return s.isEmpty();   }
+    public int size()                 { return s.size();      }
+    public Iterator<E> iterator()     { return s.iterator();  }
+    public boolean add(E e)           { return s.add(e);      }
+    public boolean remove(Object o)   { return s.remove(o);   }
+    public boolean containsAll(Collection<?> c)
+    { return s.containsAll(c); }
+    public boolean addAll(Collection<? extends E> c)
+    { return s.addAll(c);      }
+    public boolean removeAll(Collection<?> c)
+    { return s.removeAll(c);   }
+    public boolean retainAll(Collection<?> c)
+    { return s.retainAll(c);   }
+    public Object[] toArray()          { return s.toArray();  }
+    public <T> T[] toArray(T[] a)      { return s.toArray(a); }
+    @Override public boolean equals(Object o)
+    { return s.equals(o);  }
+    @Override public int hashCode()    { return s.hashCode(); }
+    @Override public String toString() { return s.toString(); }
+}

src/effectivejava/chapter11/item79/ObservableSet.java

@@ -0,0 +1,71 @@
+package effectivejava.chapter11.item79;
+import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+// Broken - invokes alien method from synchronized block!
+public class ObservableSet<E> extends ForwardingSet<E> {
+    public ObservableSet(Set<E> set) { super(set); }
+
+//    private final List<SetObserver<E>> observers
+//            = new ArrayList<>();
+
+//    public void addObserver(SetObserver<E> observer) {
+//        synchronized(observers) {
+//            observers.add(observer);
+//        }
+//    }
+//
+//    public boolean removeObserver(SetObserver<E> observer) {
+//        synchronized(observers) {
+//            return observers.remove(observer);
+//        }
+//    }
+
+//    private void notifyElementAdded(E element) {
+//        synchronized(observers) {
+//            for (SetObserver<E> observer : observers)
+//                observer.added(this, element);
+//        }
+//    }
+
+//    // Alien method moved outside of synchronized block - open calls
+//    private void notifyElementAdded(E element) {
+//        List<SetObserver<E>> snapshot = null;
+//        synchronized(observers) {
+//            snapshot = new ArrayList<>(observers);
+//        }
+//        for (SetObserver<E> observer : snapshot)
+//            observer.added(this, element);
+//    }
+
+    // Thread-safe observable set with CopyOnWriteArrayList
+    private final List<SetObserver<E>> observers =
+            new CopyOnWriteArrayList<>();
+
+    public void addObserver(SetObserver<E> observer) {
+        observers.add(observer);
+    }
+
+    public boolean removeObserver(SetObserver<E> observer) {
+        return observers.remove(observer);
+    }
+
+    private void notifyElementAdded(E element) {
+        for (SetObserver<E> observer : observers)
+            observer.added(this, element);
+    }
+
+    @Override public boolean add(E element) {
+        boolean added = super.add(element);
+        if (added)
+            notifyElementAdded(element);
+        return added;
+    }
+
+    @Override public boolean addAll(Collection<? extends E> c) {
+        boolean result = false;
+        for (E element : c)
+            result |= add(element);  // Calls notifyElementAdded
+        return result;
+    }
+}

src/effectivejava/chapter11/item79/SetObserver.java

@@ -0,0 +1,7 @@
+package effectivejava.chapter11.item79;
+
+// Set obeserver callback interface - Page 266
+public interface SetObserver<E> {
+    // Invoked when an element is added to the observable set
+    void added(ObservableSet<E> set, E element);
+}

src/effectivejava/chapter11/item79/Test1.java

@@ -0,0 +1,15 @@
+package effectivejava.chapter11.item79;
+import java.util.*;
+
+// Simple test of ObservableSet - Page 318
+public class Test1 {
+    public static void main(String[] args) {
+        ObservableSet<Integer> set =
+                new ObservableSet<>(new HashSet<>());
+
+        set.addObserver((s, e) -> System.out.println(e));
+
+        for (int i = 0; i < 100; i++)
+            set.add(i);
+    }
+}

src/effectivejava/chapter11/item79/Test2.java

@@ -0,0 +1,21 @@
+package effectivejava.chapter11.item79;
+import java.util.*;
+
+// More complex test of ObservableSet - Page 318-9
+public class Test2 {
+    public static void main(String[] args) {
+        ObservableSet<Integer> set =
+                new ObservableSet<>(new HashSet<>());
+
+        set.addObserver(new SetObserver<>() {
+            public void added(ObservableSet<Integer> s, Integer e) {
+                System.out.println(e);
+                if (e == 23)
+                    s.removeObserver(this);
+            }
+        });
+
+        for (int i = 0; i < 100; i++)
+            set.add(i);
+    }
+}

src/effectivejava/chapter11/item79/Test3.java

@@ -0,0 +1,34 @@
+package effectivejava.chapter11.item79;
+import java.util.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+// Simple test of ObservableSet - Page 319
+public class Test3 {
+    public static void main(String[] args) {
+        ObservableSet<Integer> set =
+                new ObservableSet<>(new HashSet<>());
+
+// Observer that uses a background thread needlessly
+        set.addObserver(new SetObserver<>() {
+            public void added(ObservableSet<Integer> s, Integer e) {
+                System.out.println(e);
+                if (e == 23) {
+                    ExecutorService exec =
+                            Executors.newSingleThreadExecutor();
+                    try {
+                        exec.submit(() -> s.removeObserver(this)).get();
+                    } catch (ExecutionException | InterruptedException ex) {
+                        throw new AssertionError(ex);
+                    } finally {
+                        exec.shutdown();
+                    }
+                }
+            }
+        });
+
+        for (int i = 0; i < 100; i++)
+            set.add(i);
+    }
+}

src/effectivejava/chapter11/item81/ConcurrentTimer.java

@@ -0,0 +1,34 @@
+package effectivejava.chapter11.item81;
+import java.util.concurrent.*;
+
+// Simple framework for timing concurrent execution 327
+public class ConcurrentTimer {
+    private ConcurrentTimer() { } // Noninstantiable
+
+    public static long time(Executor executor, int concurrency,
+                            Runnable action) throws InterruptedException {
+        CountDownLatch ready = new CountDownLatch(concurrency);
+        CountDownLatch start = new CountDownLatch(1);
+        CountDownLatch done  = new CountDownLatch(concurrency);
+
+        for (int i = 0; i < concurrency; i++) {
+            executor.execute(() -> {
+                ready.countDown(); // Tell timer we're ready
+                try {
+                    start.await(); // Wait till peers are ready
+                    action.run();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                } finally {
+                    done.countDown();  // Tell timer we're done
+                }
+            });
+        }
+
+        ready.await();     // Wait for all workers to be ready
+        long startNanos = System.nanoTime();
+        start.countDown(); // And they're off!
+        done.await();      // Wait for all workers to finish
+        return System.nanoTime() - startNanos;
+    }
+}