格式化代码

FindBugsFilter.xml

@@ -111,7 +111,7 @@
         <!--Should BigEgg$Yolk be a _static_ inner class?-->
         <!--Should Egg$Yolk be a _static_ inner class?-->
     </Match>
-<!-------- Checked to here ------------------------------------------------->
+    <!-------- Checked to here ------------------------------------------------->
     <Match class="Equivalence">
         <BugCode name="RC"/>
         <!--Suspicious comparison of java.lang.Integer references in Equivalence.main(String[])  At Equivalence.java:[line 7]-->

src/access/ChocolateChip.java

@@ -1,14 +1,17 @@
 package access;//: access/ChocolateChip.java
 // Can't use package-access member from another package.
+
 import access.dessert.*;
 
 public class ChocolateChip extends Cookie {
     public ChocolateChip() {
         System.out.println("ChocolateChip constructor");
     }
+
     public void chomp() {
         //! bite(); // Can't access bite
     }
+
     public static void main(String[] args) {
         ChocolateChip x = new ChocolateChip();
         x.chomp();

src/access/ChocolateChip2.java

@@ -1,11 +1,16 @@
 package access;//: access/ChocolateChip2.java
+
 import access.cookie2.*;
 
 public class ChocolateChip2 extends Cookie {
     public ChocolateChip2() {
         System.out.println("ChocolateChip2 constructor");
     }
-  public void chomp() { bite(); } // Protected method
+
+    public void chomp() {
+        bite();
+    } // Protected method
+
     public static void main(String[] args) {
         ChocolateChip2 x = new ChocolateChip2();
         x.chomp();

src/access/Dinner.java

@@ -1,5 +1,6 @@
 package access;//: access/Dinner.java
 // Uses the library.
+
 import access.dessert.*;
 
 public class Dinner {

src/access/IceCream.java

@@ -2,7 +2,9 @@ package access;//: access/IceCream.java
 // Demonstrates "private" keyword.
 
 class Sundae {
-  private Sundae() {}
+    private Sundae() {
+    }
+
     static Sundae makeASundae() {
         return new Sundae();
     }

src/access/ImportedMyClass.java

@@ -1,4 +1,5 @@
 package access;//: access/ImportedMyClass.java
+
 import access.mypackage.*;
 
 public class ImportedMyClass {

src/access/LibTest.java

@@ -1,5 +1,6 @@
 package access;//: access/LibTest.java
 // Uses the library.
+
 import net.mindview.simple.*;
 
 public class LibTest {

src/access/Lunch.java

@@ -3,7 +3,9 @@ package access;//: access/Lunch.java
 // effectively private with private constructors:
 
 class Soup1 {
-  private Soup1() {}
+    private Soup1() {
+    }
+
     // (1) Allow creation via static method:
     public static Soup1 makeSoup() {
         return new Soup1();
@@ -11,14 +13,19 @@ class Soup1 {
 }
 
 class Soup2 {
-  private Soup2() {}
+    private Soup2() {
+    }
+
     // (2) Create a static object and return a reference
     // upon request.(The "Singleton" pattern):
     private static Soup2 ps1 = new Soup2();
+
     public static Soup2 access() {
         return ps1;
     }
-  public void f() {}
+
+    public void f() {
+    }
 }
 
 // Only one public class allowed per file:
@@ -27,9 +34,11 @@ public class Lunch {
         // Can't do this! Private constructor:
         //! Soup1 soup = new Soup1();
     }
+
     void testStatic() {
         Soup1 soup = Soup1.makeSoup();
     }
+
     void testSingleton() {
         Soup2.access().f();
     }

src/access/OrganizedByAccess.java

@@ -2,11 +2,17 @@ package access;//: access/OrganizedByAccess.java
 
 public class OrganizedByAccess {
     public void pub1() { /* ... */ }
+
     public void pub2() { /* ... */ }
+
     public void pub3() { /* ... */ }
+
     private void priv1() { /* ... */ }
+
     private void priv2() { /* ... */ }
+
     private void priv3() { /* ... */ }
+
     private int i;
     // ...
 } ///:~

src/access/Pie.java

@@ -2,5 +2,7 @@ package access;//: access/Pie.java
 // The other class.
 
 class Pie {
-  void f() { System.out.println("Pie.f()"); }
+    void f() {
+        System.out.println("Pie.f()");
+    }
 } ///:~

src/access/PrintTest.java

@@ -1,5 +1,6 @@
 package access;//: access/PrintTest.java
 // Uses the static printing methods in Print.java.
+
 import static net.mindview.util.Print.*;
 
 public class PrintTest {

src/access/SingleImport.java

@@ -1,4 +1,5 @@
 package access;//: access/SingleImport.java
+
 import java.util.ArrayList;
 
 public class SingleImport {

src/access/cookie2/Cookie.java

@@ -5,6 +5,7 @@ public class Cookie {
     public Cookie() {
         System.out.println("Cookie constructor");
     }
+
     protected void bite() {
         System.out.println("bite");
     }

src/access/dessert/Cookie.java

@@ -6,5 +6,8 @@ public class Cookie {
     public Cookie() {
         System.out.println("Cookie constructor");
     }
-  void bite() { System.out.println("bite"); }
+
+    void bite() {
+        System.out.println("bite");
+    }
 } ///:~

src/annotations/AtUnitComposition.java

@@ -1,18 +1,24 @@
 //: annotations/AtUnitComposition.java
 // Creating non-embedded tests.
 package annotations;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
 
 public class AtUnitComposition {
     AtUnitExample1 testObject = new AtUnitExample1();
-  @Test boolean _methodOne() {
+
+    @Test
+    boolean _methodOne() {
         return
                 testObject.methodOne().equals("This is methodOne");
     }
-  @Test boolean _methodTwo() {
+
+    @Test
+    boolean _methodTwo() {
         return testObject.methodTwo() == 2;
     }
+
     public static void main(String[] args) throws Exception {
         OSExecute.command(
                 "java net.mindview.atunit.AtUnit AtUnitComposition");

src/annotations/AtUnitExample1.java

@@ -1,5 +1,6 @@
 //: annotations/AtUnitExample1.java
 package annotations;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
 
@@ -7,18 +8,38 @@ public class AtUnitExample1 {
     public String methodOne() {
         return "This is methodOne";
     }
+
     public int methodTwo() {
         System.out.println("This is methodTwo");
         return 2;
     }
-  @Test boolean methodOneTest() {
+
+    @Test
+    boolean methodOneTest() {
         return methodOne().equals("This is methodOne");
     }
-  @Test boolean m2() { return methodTwo() == 2; }
+
-  @Test private boolean m3() { return true; }
+    @Test
+    boolean m2() {
+        return methodTwo() == 2;
+    }
+
+    @Test
+    private boolean m3() {
+        return true;
+    }
+
     // Shows output for failure:
-  @Test boolean failureTest() { return false; }
+    @Test
-  @Test boolean anotherDisappointment() { return false; }
+    boolean failureTest() {
+        return false;
+    }
+
+    @Test
+    boolean anotherDisappointment() {
+        return false;
+    }
+
     public static void main(String[] args) throws Exception {
         OSExecute.command(
                 "java net.mindview.atunit.AtUnit AtUnitExample1");

src/annotations/AtUnitExample2.java

@@ -1,7 +1,9 @@
 //: annotations/AtUnitExample2.java
 // Assertions and exceptions can be used in @Tests.
 package annotations;
+
 import java.io.*;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
 
@@ -9,24 +11,34 @@ public class AtUnitExample2 {
     public String methodOne() {
         return "This is methodOne";
     }
+
     public int methodTwo() {
         System.out.println("This is methodTwo");
         return 2;
     }
-  @Test void assertExample() {
+
+    @Test
+    void assertExample() {
         assert methodOne().equals("This is methodOne");
     }
-  @Test void assertFailureExample() {
+
-    assert 1 == 2: "What a surprise!";
+    @Test
+    void assertFailureExample() {
+        assert 1 == 2 : "What a surprise!";
     }
-  @Test void exceptionExample() throws IOException {
+
+    @Test
+    void exceptionExample() throws IOException {
         new FileInputStream("nofile.txt"); // Throws
     }
-  @Test boolean assertAndReturn() {
+
+    @Test
+    boolean assertAndReturn() {
         // Assertion with message:
-    assert methodTwo() == 2: "methodTwo must equal 2";
+        assert methodTwo() == 2 : "methodTwo must equal 2";
         return methodOne().equals("This is methodOne");
     }
+
     public static void main(String[] args) throws Exception {
         OSExecute.command(
                 "java net.mindview.atunit.AtUnit AtUnitExample2");

src/annotations/AtUnitExample3.java

@@ -1,27 +1,49 @@
 //: annotations/AtUnitExample3.java
 package annotations;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
 
 public class AtUnitExample3 {
     private int n;
-  public AtUnitExample3(int n) { this.n = n; }
+
-  public int getN() { return n; }
+    public AtUnitExample3(int n) {
+        this.n = n;
+    }
+
+    public int getN() {
+        return n;
+    }
+
     public String methodOne() {
         return "This is methodOne";
     }
+
     public int methodTwo() {
         System.out.println("This is methodTwo");
         return 2;
     }
-  @TestObjectCreate static AtUnitExample3 create() {
+
+    @TestObjectCreate
+    static AtUnitExample3 create() {
         return new AtUnitExample3(47);
     }
-  @Test boolean initialization() { return n == 47; }
+
-  @Test boolean methodOneTest() {
+    @Test
+    boolean initialization() {
+        return n == 47;
+    }
+
+    @Test
+    boolean methodOneTest() {
         return methodOne().equals("This is methodOne");
     }
-  @Test boolean m2() { return methodTwo() == 2; }
+
+    @Test
+    boolean m2() {
+        return methodTwo() == 2;
+    }
+
     public static void main(String[] args) throws Exception {
         OSExecute.command(
                 "java net.mindview.atunit.AtUnit AtUnitExample3");

src/annotations/AtUnitExample4.java

@@ -1,8 +1,11 @@
 //: annotations/AtUnitExample4.java
 package annotations;
+
 import java.util.*;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class AtUnitExample4 {
@@ -11,36 +14,51 @@ public class AtUnitExample4 {
             "middle, and then thin again at the far end.";
     private String word;
     private Random rand = new Random(); // Time-based seed
-  public AtUnitExample4(String word) { this.word = word; }
+
-  public String getWord() { return word; }
+    public AtUnitExample4(String word) {
+        this.word = word;
+    }
+
+    public String getWord() {
+        return word;
+    }
+
     public String scrambleWord() {
         List<Character> chars = new ArrayList<Character>();
-    for(Character c : word.toCharArray()) {
+        for (Character c : word.toCharArray()) {
             chars.add(c);
         }
         Collections.shuffle(chars, rand);
         StringBuilder result = new StringBuilder();
-    for(char ch : chars) {
+        for (char ch : chars) {
             result.append(ch);
         }
         return result.toString();
     }
-  @TestProperty static List<String> input =
+
+    @TestProperty
+    static List<String> input =
             Arrays.asList(theory.split(" "));
     @TestProperty
     static Iterator<String> words = input.iterator();
-  @TestObjectCreate static AtUnitExample4 create() {
+
-    if(words.hasNext()) {
+    @TestObjectCreate
+    static AtUnitExample4 create() {
+        if (words.hasNext()) {
             return new AtUnitExample4(words.next());
         } else {
             return null;
         }
     }
-  @Test boolean words() {
+
+    @Test
+    boolean words() {
         print("'" + getWord() + "'");
         return getWord().equals("are");
     }
-  @Test boolean scramble1() {
+
+    @Test
+    boolean scramble1() {
         // Change to a specific seed to get verifiable results:
         rand = new Random(47);
         print("'" + getWord() + "'");
@@ -48,13 +66,16 @@ public class AtUnitExample4 {
         print(scrambled);
         return scrambled.equals("lAl");
     }
-  @Test boolean scramble2() {
+
+    @Test
+    boolean scramble2() {
         rand = new Random(74);
         print("'" + getWord() + "'");
         String scrambled = scrambleWord();
         print(scrambled);
         return scrambled.equals("tsaeborornussu");
     }
+
     public static void main(String[] args) throws Exception {
         System.out.println("starting");
         OSExecute.command(

src/annotations/AtUnitExample5.java

@@ -1,41 +1,64 @@
 //: annotations/AtUnitExample5.java
 package annotations;
+
 import java.io.*;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
 
 public class AtUnitExample5 {
     private String text;
-  public AtUnitExample5(String text) { this.text = text; }
+
-  public String toString() { return text; }
+    public AtUnitExample5(String text) {
-  @TestProperty static PrintWriter output;
+        this.text = text;
-  @TestProperty static int counter;
+    }
-  @TestObjectCreate static AtUnitExample5 create() {
+
+    @Override
+    public String toString() {
+        return text;
+    }
+
+    @TestProperty
+    static PrintWriter output;
+    @TestProperty
+    static int counter;
+
+    @TestObjectCreate
+    static AtUnitExample5 create() {
         String id = Integer.toString(counter++);
         try {
             output = new PrintWriter("Test" + id + ".txt");
-    } catch(IOException e) {
+        } catch (IOException e) {
             throw new RuntimeException(e);
         }
         return new AtUnitExample5(id);
     }
-  @TestObjectCleanup static void
+
+    @TestObjectCleanup
+    static void
     cleanup(AtUnitExample5 tobj) {
         System.out.println("Running cleanup");
         output.close();
     }
-  @Test boolean test1() {
+
+    @Test
+    boolean test1() {
         output.print("test1");
         return true;
     }
-  @Test boolean test2() {
+
+    @Test
+    boolean test2() {
         output.print("test2");
         return true;
     }
-  @Test boolean test3() {
+
+    @Test
+    boolean test3() {
         output.print("test3");
         return true;
     }
+
     public static void main(String[] args) throws Exception {
         OSExecute.command(
                 "java net.mindview.atunit.AtUnit AtUnitExample5");

src/annotations/AtUnitExternalTest.java

@@ -1,14 +1,21 @@
 //: annotations/AtUnitExternalTest.java
 // Creating non-embedded tests.
 package annotations;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
 
 public class AtUnitExternalTest extends AtUnitExample1 {
-  @Test boolean _methodOne() {
+    @Test
+    boolean _methodOne() {
         return methodOne().equals("This is methodOne");
     }
-  @Test boolean _methodTwo() { return methodTwo() == 2; }
+
+    @Test
+    boolean _methodTwo() {
+        return methodTwo() == 2;
+    }
+
     public static void main(String[] args) throws Exception {
         OSExecute.command(
                 "java net.mindview.atunit.AtUnit AtUnitExternalTest");

src/annotations/ExtractInterface.java

@@ -1,6 +1,7 @@
 //: annotations/ExtractInterface.java
 // APT-based annotation processing.
 package annotations;
+
 import java.lang.annotation.*;
 
 @Target(ElementType.TYPE)

src/annotations/HashSetTest.java

@@ -1,23 +1,32 @@
 //: annotations/HashSetTest.java
 package annotations;
+
 import java.util.*;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
 
 public class HashSetTest {
     HashSet<String> testObject = new HashSet<String>();
-  @Test void initialization() {
+
+    @Test
+    void initialization() {
         assert testObject.isEmpty();
     }
-  @Test void _contains() {
+
+    @Test
+    void _contains() {
         testObject.add("one");
         assert testObject.contains("one");
     }
-  @Test void _remove() {
+
+    @Test
+    void _remove() {
         testObject.add("one");
         testObject.remove("one");
         assert testObject.isEmpty();
     }
+
     public static void main(String[] args) throws Exception {
         OSExecute.command(
                 "java net.mindview.atunit.AtUnit HashSetTest");

src/annotations/InterfaceExtractorProcessor.java

@@ -4,8 +4,10 @@
 // annotations.InterfaceExtractorProcessorFactory
 // Multiplier.java -s ../annotations}
 package annotations;
+
 import com.sun.mirror.apt.*;
 import com.sun.mirror.declaration.*;
+
 import java.io.*;
 import java.util.*;
 
@@ -14,40 +16,44 @@ public class InterfaceExtractorProcessor
     private final AnnotationProcessorEnvironment env;
     private ArrayList<MethodDeclaration> interfaceMethods =
             new ArrayList<MethodDeclaration>();
+
     public InterfaceExtractorProcessor(
-    AnnotationProcessorEnvironment env) { this.env = env; }
+            AnnotationProcessorEnvironment env) {
+        this.env = env;
+    }
+
     public void process() {
-    for(TypeDeclaration typeDecl :
+        for (TypeDeclaration typeDecl :
                 env.getSpecifiedTypeDeclarations()) {
             ExtractInterface annot =
                     typeDecl.getAnnotation(ExtractInterface.class);
-      if(annot == null) {
+            if (annot == null) {
                 break;
             }
-      for(MethodDeclaration m : typeDecl.getMethods()) {
+            for (MethodDeclaration m : typeDecl.getMethods()) {
-          if(m.getModifiers().contains(Modifier.PUBLIC) &&
+                if (m.getModifiers().contains(Modifier.PUBLIC) &&
                         !(m.getModifiers().contains(Modifier.STATIC))) {
                     interfaceMethods.add(m);
                 }
             }
-      if(interfaceMethods.size() > 0) {
+            if (interfaceMethods.size() > 0) {
                 try {
                     PrintWriter writer =
                             env.getFiler().createSourceFile(annot.value());
                     writer.println("package " +
-            typeDecl.getPackage().getQualifiedName() +";");
+                            typeDecl.getPackage().getQualifiedName() + ";");
                     writer.println("public interface " +
                             annot.value() + " {");
-          for(MethodDeclaration m : interfaceMethods) {
+                    for (MethodDeclaration m : interfaceMethods) {
                         writer.print("  public ");
                         writer.print(m.getReturnType() + " ");
                         writer.print(m.getSimpleName() + " (");
                         int i = 0;
-            for(ParameterDeclaration parm :
+                        for (ParameterDeclaration parm :
                                 m.getParameters()) {
                             writer.print(parm.getType() + " " +
                                     parm.getSimpleName());
-              if(++i < m.getParameters().size()) {
+                            if (++i < m.getParameters().size()) {
                                 writer.print(", ");
                             }
                         }
@@ -55,7 +61,7 @@ public class InterfaceExtractorProcessor
                     }
                     writer.println("}");
                     writer.close();
-        } catch(IOException ioe) {
+                } catch (IOException ioe) {
                     throw new RuntimeException(ioe);
                 }
             }

src/annotations/InterfaceExtractorProcessorFactory.java

@@ -1,8 +1,10 @@
 //: annotations/InterfaceExtractorProcessorFactory.java
 // APT-based annotation processing.
 package annotations;
+
 import com.sun.mirror.apt.*;
 import com.sun.mirror.declaration.*;
+
 import java.util.*;
 
 public class InterfaceExtractorProcessorFactory
@@ -12,10 +14,12 @@ public class InterfaceExtractorProcessorFactory
             AnnotationProcessorEnvironment env) {
         return new InterfaceExtractorProcessor(env);
     }
+
     public Collection<String> supportedAnnotationTypes() {
         return
                 Collections.singleton("annotations.ExtractInterface");
     }
+
     public Collection<String> supportedOptions() {
         return Collections.emptySet();
     }

src/annotations/Multiplier.java

@@ -6,12 +6,16 @@ package annotations;
 public class Multiplier {
     public int multiply(int x, int y) {
         int total = 0;
-    for(int i = 0; i < x; i++) {
+        for (int i = 0; i < x; i++) {
             total = add(total, y);
         }
         return total;
     }
-  private int add(int x, int y) { return x + y; }
+
+    private int add(int x, int y) {
+        return x + y;
+    }
+
     public static void main(String[] args) {
         Multiplier m = new Multiplier();
         System.out.println("11*16 = " + m.multiply(11, 16));

src/annotations/PasswordUtils.java

@@ -1,4 +1,5 @@
 package annotations;//: annotations/PasswordUtils.java
+
 import java.util.*;
 
 public class PasswordUtils {
@@ -7,10 +8,12 @@ public class PasswordUtils {
     public boolean validatePassword(String password) {
         return (password.matches("\\w*\\d\\w*"));
     }
+
     @UseCase(id = 48)
     public String encryptPassword(String password) {
         return new StringBuilder(password).reverse().toString();
     }
+
     @UseCase(id = 49, description =
             "New passwords can't equal previously used ones")
     public boolean checkForNewPassword(

src/annotations/SimulatingNull.java

@@ -1,9 +1,11 @@
 package annotations;//: annotations/SimulatingNull.java
+
 import java.lang.annotation.*;
 
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface SimulatingNull {
     public int id() default -1;
+
     public String description() default "";
 } ///:~

src/annotations/StackL.java

@@ -1,11 +1,21 @@
 //: annotations/StackL.java
 // A stack built on a linkedList.
 package annotations;
+
 import java.util.*;
 
 public class StackL<T> {
     private LinkedList<T> list = new LinkedList<T>();
-  public void push(T v) { list.addFirst(v); }
+
-  public T top() { return list.getFirst(); }
+    public void push(T v) {
-  public T pop() { return list.removeFirst(); }
+        list.addFirst(v);
+    }
+
+    public T top() {
+        return list.getFirst();
+    }
+
+    public T pop() {
+        return list.removeFirst();
+    }
 } ///:~

src/annotations/StackLStringTest.java

@@ -1,28 +1,35 @@
 //: annotations/StackLStringTest.java
 // Applying @Unit to generics.
 package annotations;
+
 import net.mindview.atunit.*;
 import net.mindview.util.*;
 
 public class StackLStringTest extends StackL<String> {
-  @Test void _push() {
+    @Test
+    void _push() {
         push("one");
         assert top().equals("one");
         push("two");
         assert top().equals("two");
     }
-  @Test void _pop() {
+
+    @Test
+    void _pop() {
         push("one");
         push("two");
         assert pop().equals("two");
         assert pop().equals("one");
     }
-  @Test void _top() {
+
+    @Test
+    void _top() {
         push("A");
         push("B");
         assert top().equals("B");
         assert top().equals("B");
     }
+
     public static void main(String[] args) throws Exception {
         OSExecute.command(
                 "java net.mindview.atunit.AtUnit StackLStringTest");

src/annotations/Testable.java

@@ -1,10 +1,15 @@
 //: annotations/Testable.java
 package annotations;
+
 import net.mindview.atunit.*;
 
 public class Testable {
     public void execute() {
         System.out.println("Executing..");
     }
-  @Test void testExecute() { execute(); }
+
+    @Test
+    void testExecute() {
+        execute();
+    }
 } ///:~

src/annotations/UseCase.java

@@ -1,9 +1,11 @@
 package annotations;//: annotations/UseCase.java
+
 import java.lang.annotation.*;
 
 @Target(ElementType.METHOD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface UseCase {
     public int id();
+
     public String description() default "no description";
 } ///:~

src/annotations/UseCaseTracker.java

@@ -1,22 +1,24 @@
 package annotations;//: annotations/UseCaseTracker.java
+
 import java.lang.reflect.*;
 import java.util.*;
 
 public class UseCaseTracker {
     public static void
     trackUseCases(List<Integer> useCases, Class<?> cl) {
-    for(Method m : cl.getDeclaredMethods()) {
+        for (Method m : cl.getDeclaredMethods()) {
             UseCase uc = m.getAnnotation(UseCase.class);
-      if(uc != null) {
+            if (uc != null) {
                 System.out.println("Found Use Case:" + uc.id() +
                         " " + uc.description());
                 useCases.remove(new Integer(uc.id()));
             }
         }
-    for(int i : useCases) {
+        for (int i : useCases) {
             System.out.println("Warning: Missing use case-" + i);
         }
     }
+
     public static void main(String[] args) {
         List<Integer> useCases = new ArrayList<Integer>();
         Collections.addAll(useCases, 47, 48, 49, 50);

src/annotations/database/Constraints.java

@@ -1,11 +1,14 @@
 //: annotations/database/Constraints.java
 package annotations.database;
+
 import java.lang.annotation.*;
 
 @Target(ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Constraints {
     boolean primaryKey() default false;
+
     boolean allowNull() default true;
+
     boolean unique() default false;
 } ///:~

src/annotations/database/DBTable.java

@@ -1,5 +1,6 @@
 //: annotations/database/DBTable.java
 package annotations.database;
+
 import java.lang.annotation.*;
 
 @Target(ElementType.TYPE) // Applies to classes only

src/annotations/database/Member.java

@@ -3,16 +3,35 @@ package annotations.database;
 
 @DBTable(name = "MEMBER")
 public class Member {
-  @SQLString(30) String firstName;
+    @SQLString(30)
-  @SQLString(50) String lastName;
+    String firstName;
-  @SQLInteger Integer age;
+    @SQLString(50)
+    String lastName;
+    @SQLInteger
+    Integer age;
     @SQLString(value = 30,
             constraints = @Constraints(primaryKey = true))
     String handle;
     static int memberCount;
-  public String getHandle() { return handle; }
+
-  public String getFirstName() { return firstName; }
+    public String getHandle() {
-  public String getLastName() { return lastName; }
+        return handle;
-  public String toString() { return handle; }
+    }
-  public Integer getAge() { return age; }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    @Override
+    public String toString() {
+        return handle;
+    }
+
+    public Integer getAge() {
+        return age;
+    }
 } ///:~

src/annotations/database/SQLInteger.java

@@ -1,10 +1,12 @@
 //: annotations/database/SQLInteger.java
 package annotations.database;
+
 import java.lang.annotation.*;
 
 @Target(ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface SQLInteger {
     String name() default "";
+
     Constraints constraints() default @Constraints;
 } ///:~

src/annotations/database/SQLString.java

@@ -1,11 +1,14 @@
 //: annotations/database/SQLString.java
 package annotations.database;
+
 import java.lang.annotation.*;
 
 @Target(ElementType.FIELD)
 @Retention(RetentionPolicy.RUNTIME)
 public @interface SQLString {
     int value() default 0;
+
     String name() default "";
+
     Constraints constraints() default @Constraints;
 } ///:~

src/annotations/database/TableCreationProcessorFactory.java

@@ -4,10 +4,13 @@
 // annotations.database.TableCreationProcessorFactory
 // database/Member.java -s database}
 package annotations.database;
+
 import com.sun.mirror.apt.*;
 import com.sun.mirror.declaration.*;
 import com.sun.mirror.util.*;
+
 import java.util.*;
+
 import static com.sun.mirror.util.DeclarationVisitors.*;
 
 public class TableCreationProcessorFactory
@@ -17,6 +20,7 @@ public class TableCreationProcessorFactory
             AnnotationProcessorEnvironment env) {
         return new TableCreationProcessor(env);
     }
+
     public Collection<String> supportedAnnotationTypes() {
         return Arrays.asList(
                 "annotations.database.DBTable",
@@ -24,19 +28,23 @@ public class TableCreationProcessorFactory
                 "annotations.database.SQLString",
                 "annotations.database.SQLInteger");
     }
+
     public Collection<String> supportedOptions() {
         return Collections.emptySet();
     }
+
     private static class TableCreationProcessor
             implements AnnotationProcessor {
         private final AnnotationProcessorEnvironment env;
         private String sql = "";
+
         public TableCreationProcessor(
                 AnnotationProcessorEnvironment env) {
             this.env = env;
         }
+
         public void process() {
-      for(TypeDeclaration typeDecl :
+            for (TypeDeclaration typeDecl :
                     env.getSpecifiedTypeDeclarations()) {
                 typeDecl.accept(getDeclarationScanner(
                         new TableCreationVisitor(), NO_OP));
@@ -45,12 +53,13 @@ public class TableCreationProcessorFactory
                 sql = "";
             }
         }
+
         private class TableCreationVisitor
                 extends SimpleDeclarationVisitor {
             public void visitClassDeclaration(
                     ClassDeclaration d) {
                 DBTable dbTable = d.getAnnotation(DBTable.class);
-        if(dbTable != null) {
+                if (dbTable != null) {
                     sql += "CREATE TABLE ";
                     sql += (dbTable.name().length() < 1)
                             ? d.getSimpleName().toUpperCase()
@@ -58,14 +67,15 @@ public class TableCreationProcessorFactory
                     sql += " (";
                 }
             }
+
             public void visitFieldDeclaration(
                     FieldDeclaration d) {
                 String columnName = "";
-        if(d.getAnnotation(SQLInteger.class) != null) {
+                if (d.getAnnotation(SQLInteger.class) != null) {
                     SQLInteger sInt = d.getAnnotation(
                             SQLInteger.class);
                     // Use field name if name not specified
-          if(sInt.name().length() < 1) {
+                    if (sInt.name().length() < 1) {
                         columnName = d.getSimpleName().toUpperCase();
                     } else {
                         columnName = sInt.name();
@@ -73,11 +83,11 @@ public class TableCreationProcessorFactory
                     sql += "\n    " + columnName + " INT" +
                             getConstraints(sInt.constraints()) + ",";
                 }
-        if(d.getAnnotation(SQLString.class) != null) {
+                if (d.getAnnotation(SQLString.class) != null) {
                     SQLString sString = d.getAnnotation(
                             SQLString.class);
                     // Use field name if name not specified.
-          if(sString.name().length() < 1) {
+                    if (sString.name().length() < 1) {
                         columnName = d.getSimpleName().toUpperCase();
                     } else {
                         columnName = sString.name();
@@ -87,15 +97,16 @@ public class TableCreationProcessorFactory
                             getConstraints(sString.constraints()) + ",";
                 }
             }
+
             private String getConstraints(Constraints con) {
                 String constraints = "";
-        if(!con.allowNull()) {
+                if (!con.allowNull()) {
                     constraints += " NOT NULL";
                 }
-        if(con.primaryKey()) {
+                if (con.primaryKey()) {
                     constraints += " PRIMARY KEY";
                 }
-        if(con.unique()) {
+                if (con.unique()) {
                     constraints += " UNIQUE";
                 }
                 return constraints;

src/annotations/database/TableCreator.java

@@ -2,40 +2,41 @@
 // Reflection-based annotation processor.
 // {Args: annotations.database.Member}
 package annotations.database;
+
 import java.lang.annotation.*;
 import java.lang.reflect.*;
 import java.util.*;
 
 public class TableCreator {
     public static void main(String[] args) throws Exception {
-    if(args.length < 1) {
+        if (args.length < 1) {
             System.out.println("arguments: annotated classes");
             System.exit(0);
         }
-    for(String className : args) {
+        for (String className : args) {
             Class<?> cl = Class.forName(className);
             DBTable dbTable = cl.getAnnotation(DBTable.class);
-      if(dbTable == null) {
+            if (dbTable == null) {
                 System.out.println(
                         "No DBTable annotations in class " + className);
                 continue;
             }
             String tableName = dbTable.name();
             // If the name is empty, use the Class name:
-      if(tableName.length() < 1) {
+            if (tableName.length() < 1) {
                 tableName = cl.getName().toUpperCase();
             }
             List<String> columnDefs = new ArrayList<String>();
-      for(Field field : cl.getDeclaredFields()) {
+            for (Field field : cl.getDeclaredFields()) {
                 String columnName = null;
                 Annotation[] anns = field.getDeclaredAnnotations();
-        if(anns.length < 1) {
+                if (anns.length < 1) {
                     continue; // Not a db table column
                 }
-        if(anns[0] instanceof SQLInteger) {
+                if (anns[0] instanceof SQLInteger) {
                     SQLInteger sInt = (SQLInteger) anns[0];
                     // Use field name if name not specified
-          if(sInt.name().length() < 1) {
+                    if (sInt.name().length() < 1) {
                         columnName = field.getName().toUpperCase();
                     } else {
                         columnName = sInt.name();
@@ -43,10 +44,10 @@ public class TableCreator {
                     columnDefs.add(columnName + " INT" +
                             getConstraints(sInt.constraints()));
                 }
-        if(anns[0] instanceof SQLString) {
+                if (anns[0] instanceof SQLString) {
                     SQLString sString = (SQLString) anns[0];
                     // Use field name if name not specified.
-          if(sString.name().length() < 1) {
+                    if (sString.name().length() < 1) {
                         columnName = field.getName().toUpperCase();
                     } else {
                         columnName = sString.name();
@@ -57,7 +58,7 @@ public class TableCreator {
                 }
                 StringBuilder createCommand = new StringBuilder(
                         "CREATE TABLE " + tableName + "(");
-        for(String columnDef : columnDefs) {
+                for (String columnDef : columnDefs) {
                     createCommand.append("\n    " + columnDef + ",");
                 }
                 // Remove trailing comma
@@ -68,15 +69,16 @@ public class TableCreator {
             }
         }
     }
+
     private static String getConstraints(Constraints con) {
         String constraints = "";
-    if(!con.allowNull()) {
+        if (!con.allowNull()) {
             constraints += " NOT NULL";
         }
-    if(con.primaryKey()) {
+        if (con.primaryKey()) {
             constraints += " PRIMARY KEY";
         }
-    if(con.unique()) {
+        if (con.unique()) {
             constraints += " UNIQUE";
         }
         return constraints;

src/annotations/database/Uniqueness.java

@@ -4,5 +4,5 @@ package annotations.database;
 
 public @interface Uniqueness {
     Constraints constraints()
-    default @Constraints(unique=true);
+            default @Constraints(unique = true);
 } ///:~

src/arrays/AlphabeticSearch.java

@@ -1,6 +1,8 @@
 package arrays;//: arrays/AlphabeticSearch.java
 // Searching with a Comparator.
+
 import java.util.*;
+
 import net.mindview.util.*;
 
 public class AlphabeticSearch {
@@ -11,7 +13,7 @@ public class AlphabeticSearch {
         System.out.println(Arrays.toString(sa));
         int index = Arrays.binarySearch(sa, sa[10],
                 String.CASE_INSENSITIVE_ORDER);
-    System.out.println("Index: "+ index + "\n"+ sa[index]);
+        System.out.println("Index: " + index + "\n" + sa[index]);
     }
 } /* Output:
 [bkIna, cQrGs, cXZJo, dLsmw, eGZMm, EqUCB, gwsqP, hKcxr, HLGEa, HqXum, HxxHv, JMRoE, JmzMs, Mesbt, MNvqe, nyGcF, ogoYW, OneOE, OWZnT, RFJQA, rUkZP, sgqia, slJrL, suEcU, uTpnX, vpfFv, WHkjU, xxEAJ, YNzbr, zDyCy]

src/arrays/ArrayOfGenericType.java

@@ -3,10 +3,11 @@ package arrays;//: arrays/ArrayOfGenericType.java
 
 public class ArrayOfGenericType<T> {
     T[] array; // OK
+
     @SuppressWarnings("unchecked")
     public ArrayOfGenericType(int size) {
         //! array = new T[size]; // Illegal
-    array = (T[])new Object[size]; // "unchecked" Warning
+        array = (T[]) new Object[size]; // "unchecked" Warning
     }
     // Illegal:
     //! public <U> U[] makeArray() { return new U[10]; }

src/arrays/ArrayOfGenerics.java

@@ -1,5 +1,6 @@
 package arrays;//: arrays/ArrayOfGenerics.java
 // It is possible to create arrays of generics.
+
 import java.util.*;
 
 public class ArrayOfGenerics {
@@ -7,7 +8,7 @@ public class ArrayOfGenerics {
     public static void main(String[] args) {
         List<String>[] ls;
         List[] la = new List[10];
-    ls = (List<String>[])la; // "Unchecked" warning
+        ls = (List<String>[]) la; // "Unchecked" warning
         ls[0] = new ArrayList<String>();
         // Compile-time checking produces an error:
         //! ls[1] = new ArrayList<Integer>();
@@ -21,8 +22,8 @@ public class ArrayOfGenerics {
         // possible to create an array of generics, albeit
         // with an "unchecked" warning:
         List<BerylliumSphere>[] spheres =
-      (List<BerylliumSphere>[])new List[10];
+                (List<BerylliumSphere>[]) new List[10];
-    for(int i = 0; i < spheres.length; i++) {
+        for (int i = 0; i < spheres.length; i++) {
             spheres[i] = new ArrayList<BerylliumSphere>();
         }
     }

src/arrays/ArrayOptions.java

@@ -1,6 +1,8 @@
 package arrays;//: arrays/ArrayOptions.java
 // Initialization & re-assignment of arrays.
+
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class ArrayOptions {
@@ -12,14 +14,14 @@ public class ArrayOptions {
         // automatically initialized to null:
         print("b: " + Arrays.toString(b));
         BerylliumSphere[] c = new BerylliumSphere[4];
-    for(int i = 0; i < c.length; i++) {
+        for (int i = 0; i < c.length; i++) {
-        if(c[i] == null) // Can test for null reference
+            if (c[i] == null) // Can test for null reference
             {
                 c[i] = new BerylliumSphere();
             }
         }
         // Aggregate initialization:
-    BerylliumSphere[] d = { new BerylliumSphere(),
+        BerylliumSphere[] d = {new BerylliumSphere(),
                 new BerylliumSphere(), new BerylliumSphere()
         };
         // Dynamic aggregate initialization:
@@ -41,10 +43,10 @@ public class ArrayOptions {
         // automatically initialized to zero:
         print("f: " + Arrays.toString(f));
         int[] g = new int[4];
-    for(int i = 0; i < g.length; i++) {
+        for (int i = 0; i < g.length; i++) {
-        g[i] = i*i;
+            g[i] = i * i;
         }
-    int[] h = { 11, 47, 93 };
+        int[] h = {11, 47, 93};
         // Compile error: variable e not initialized:
         //!print("e.length = " + e.length);
         print("f.length = " + f.length);
@@ -52,7 +54,7 @@ public class ArrayOptions {
         print("h.length = " + h.length);
         e = h;
         print("e.length = " + e.length);
-    e = new int[]{ 1, 2 };
+        e = new int[]{1, 2};
         print("e.length = " + e.length);
     }
 } /* Output:

src/arrays/ArraySearching.java

@@ -1,7 +1,10 @@
 package arrays;//: arrays/ArraySearching.java
 // Using Arrays.binarySearch().
+
 import java.util.*;
+
 import net.mindview.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class ArraySearching {
@@ -12,10 +15,10 @@ public class ArraySearching {
                 Generated.array(new Integer[25], gen));
         Arrays.sort(a);
         print("Sorted array: " + Arrays.toString(a));
-    while(true) {
+        while (true) {
             int r = gen.next();
             int location = Arrays.binarySearch(a, r);
-      if(location >= 0) {
+            if (location >= 0) {
                 print("Location of " + r + " is " + location +
                         ", a[" + location + "] = " + a[location]);
                 break; // Out of while loop

src/arrays/AssemblingMultidimensionalArrays.java

@@ -1,14 +1,15 @@
 package arrays;//: arrays/AssemblingMultidimensionalArrays.java
 // Creating multidimensional arrays.
+
 import java.util.*;
 
 public class AssemblingMultidimensionalArrays {
     public static void main(String[] args) {
         Integer[][] a;
         a = new Integer[3][];
-    for(int i = 0; i < a.length; i++) {
+        for (int i = 0; i < a.length; i++) {
             a[i] = new Integer[3];
-      for(int j = 0; j < a[i].length; j++) {
+            for (int j = 0; j < a[i].length; j++) {
                 a[i][j] = i * j; // Autoboxing
             }
         }

src/arrays/AutoboxingArrays.java

@@ -1,13 +1,14 @@
 package arrays;//: arrays/AutoboxingArrays.java
+
 import java.util.*;
 
 public class AutoboxingArrays {
     public static void main(String[] args) {
         Integer[][] a = { // Autoboxing:
-      { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 },
+                {1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
-      { 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 },
+                {21, 22, 23, 24, 25, 26, 27, 28, 29, 30},
-      { 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 },
+                {51, 52, 53, 54, 55, 56, 57, 58, 59, 60},
-      { 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 },
+                {71, 72, 73, 74, 75, 76, 77, 78, 79, 80},
         };
         System.out.println(Arrays.deepToString(a));
     }

src/arrays/CompType.java

@@ -1,35 +1,47 @@
 package arrays;//: arrays/CompType.java
 // Implementing Comparable in a class.
+
 import java.util.*;
+
 import net.mindview.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class CompType implements Comparable<CompType> {
     int i;
     int j;
     private static int count = 1;
+
     public CompType(int n1, int n2) {
         i = n1;
         j = n2;
     }
+
+    @Override
     public String toString() {
         String result = "[i = " + i + ", j = " + j + "]";
-    if(count++ % 3 == 0) {
+        if (count++ % 3 == 0) {
             result += "\n";
         }
         return result;
     }
+
+    @Override
     public int compareTo(CompType rv) {
         return (i < rv.i ? -1 : (i == rv.i ? 0 : 1));
     }
+
     private static Random r = new Random(47);
+
     public static Generator<CompType> generator() {
         return new Generator<CompType>() {
+            @Override
             public CompType next() {
-        return new CompType(r.nextInt(100),r.nextInt(100));
+                return new CompType(r.nextInt(100), r.nextInt(100));
             }
         };
     }
+
     public static void main(String[] args) {
         CompType[] a =
                 Generated.array(new CompType[12], generator());

src/arrays/ComparatorTest.java

@@ -1,10 +1,14 @@
 package arrays;//: arrays/ComparatorTest.java
 // Implementing a Comparator for a class.
+
 import java.util.*;
+
 import net.mindview.util.*;
+
 import static net.mindview.util.Print.*;
 
 class CompTypeComparator implements Comparator<CompType> {
+    @Override
     public int compare(CompType o1, CompType o2) {
         return (o1.j < o2.j ? -1 : (o1.j == o2.j ? 0 : 1));
     }

src/arrays/ComparingArrays.java

@@ -1,6 +1,8 @@
 package arrays;//: arrays/ComparingArrays.java
 // Using Arrays.equals()
+
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class ComparingArrays {
@@ -14,8 +16,8 @@ public class ComparingArrays {
         print(Arrays.equals(a1, a2));
         String[] s1 = new String[4];
         Arrays.fill(s1, "Hi");
-    String[] s2 = { new String("Hi"), new String("Hi"),
+        String[] s2 = {new String("Hi"), new String("Hi"),
-      new String("Hi"), new String("Hi") };
+                new String("Hi"), new String("Hi")};
         print(Arrays.equals(s1, s2));
     }
 } /* Output:

src/arrays/ContainerComparison.java

@@ -1,17 +1,23 @@
 package arrays;//: arrays/ContainerComparison.java
+
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 class BerylliumSphere {
     private static long counter;
     private final long id = counter++;
-  public String toString() { return "Sphere " + id; }
+
+    @Override
+    public String toString() {
+        return "Sphere " + id;
+    }
 }
 
 public class ContainerComparison {
     public static void main(String[] args) {
         BerylliumSphere[] spheres = new BerylliumSphere[10];
-    for(int i = 0; i < 5; i++) {
+        for (int i = 0; i < 5; i++) {
             spheres[i] = new BerylliumSphere();
         }
         print(Arrays.toString(spheres));
@@ -19,13 +25,13 @@ public class ContainerComparison {
 
         List<BerylliumSphere> sphereList =
                 new ArrayList<BerylliumSphere>();
-    for(int i = 0; i < 5; i++) {
+        for (int i = 0; i < 5; i++) {
             sphereList.add(new BerylliumSphere());
         }
         print(sphereList);
         print(sphereList.get(4));
 
-    int[] integers = { 0, 1, 2, 3, 4, 5 };
+        int[] integers = {0, 1, 2, 3, 4, 5};
         print(Arrays.toString(integers));
         print(integers[4]);
 

src/arrays/CopyingArrays.java

@@ -1,6 +1,8 @@
 package arrays;//: arrays/CopyingArrays.java
 // Using System.arraycopy()
+
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class CopyingArrays {
@@ -27,7 +29,7 @@ public class CopyingArrays {
         Arrays.fill(v, new Integer(99));
         print("u = " + Arrays.toString(u));
         print("v = " + Arrays.toString(v));
-    System.arraycopy(v, 0, u, u.length/2, v.length);
+        System.arraycopy(v, 0, u, u.length / 2, v.length);
         print("u = " + Arrays.toString(u));
     }
 } /* Output:

src/arrays/FillingArrays.java

@@ -1,6 +1,8 @@
 package arrays;//: arrays/FillingArrays.java
 // Using Arrays.fill()
+
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class FillingArrays {
@@ -17,11 +19,11 @@ public class FillingArrays {
         String[] a9 = new String[size];
         Arrays.fill(a1, true);
         print("a1 = " + Arrays.toString(a1));
-    Arrays.fill(a2, (byte)11);
+        Arrays.fill(a2, (byte) 11);
         print("a2 = " + Arrays.toString(a2));
         Arrays.fill(a3, 'x');
         print("a3 = " + Arrays.toString(a3));
-    Arrays.fill(a4, (short)17);
+        Arrays.fill(a4, (short) 17);
         print("a4 = " + Arrays.toString(a4));
         Arrays.fill(a5, 19);
         print("a5 = " + Arrays.toString(a5));

src/arrays/GeneratorsTest.java

@@ -1,22 +1,25 @@
 package arrays;//: arrays/GeneratorsTest.java
+
 import net.mindview.util.*;
 
 public class GeneratorsTest {
     public static int size = 10;
+
     public static void test(Class<?> surroundingClass) {
-    for(Class<?> type : surroundingClass.getClasses()) {
+        for (Class<?> type : surroundingClass.getClasses()) {
             System.out.print(type.getSimpleName() + ": ");
             try {
-        Generator<?> g = (Generator<?>)type.newInstance();
+                Generator<?> g = (Generator<?>) type.newInstance();
-        for(int i = 0; i < size; i++) {
+                for (int i = 0; i < size; i++) {
                     System.out.printf(g.next() + " ");
                 }
                 System.out.println();
-      } catch(Exception e) {
+            } catch (Exception e) {
                 throw new RuntimeException(e);
             }
         }
     }
+
     public static void main(String[] args) {
         test(CountingGenerator.class);
     }

src/arrays/IceCream.java

@@ -1,5 +1,6 @@
 package arrays;//: arrays/IceCream.java
 // Returning arrays from methods.
+
 import java.util.*;
 
 public class IceCream {
@@ -9,25 +10,27 @@ public class IceCream {
             "Mint Chip", "Mocha Almond Fudge", "Rum Raisin",
             "Praline Cream", "Mud Pie"
     };
+
     public static String[] flavorSet(int n) {
-    if(n > FLAVORS.length) {
+        if (n > FLAVORS.length) {
             throw new IllegalArgumentException("Set too big");
         }
         String[] results = new String[n];
         boolean[] picked = new boolean[FLAVORS.length];
-    for(int i = 0; i < n; i++) {
+        for (int i = 0; i < n; i++) {
             int t;
             do {
                 t = rand.nextInt(FLAVORS.length);
             }
-      while(picked[t]);
+            while (picked[t]);
             results[i] = FLAVORS[t];
             picked[t] = true;
         }
         return results;
     }
+
     public static void main(String[] args) {
-    for(int i = 0; i < 7; i++) {
+        for (int i = 0; i < 7; i++) {
             System.out.println(Arrays.toString(flavorSet(3)));
         }
     }

src/arrays/MultiDimWrapperArray.java

@@ -1,22 +1,23 @@
 package arrays;//: arrays/MultiDimWrapperArray.java
 // Multidimensional arrays of "wrapper" objects.
+
 import java.util.*;
 
 public class MultiDimWrapperArray {
     public static void main(String[] args) {
         Integer[][] a1 = { // Autoboxing
-      { 1, 2, 3, },
+                {1, 2, 3,},
-      { 4, 5, 6, },
+                {4, 5, 6,},
         };
         Double[][][] a2 = { // Autoboxing
-      { { 1.1, 2.2 }, { 3.3, 4.4 } },
+                {{1.1, 2.2}, {3.3, 4.4}},
-      { { 5.5, 6.6 }, { 7.7, 8.8 } },
+                {{5.5, 6.6}, {7.7, 8.8}},
-      { { 9.9, 1.2 }, { 2.3, 3.4 } },
+                {{9.9, 1.2}, {2.3, 3.4}},
         };
         String[][] a3 = {
-      { "The", "Quick", "Sly", "Fox" },
+                {"The", "Quick", "Sly", "Fox"},
-      { "Jumped", "Over" },
+                {"Jumped", "Over"},
-      { "The", "Lazy", "Brown", "Dog", "and", "friend" },
+                {"The", "Lazy", "Brown", "Dog", "and", "friend"},
         };
         System.out.println("a1: " + Arrays.deepToString(a1));
         System.out.println("a2: " + Arrays.deepToString(a2));

src/arrays/MultidimensionalObjectArrays.java

@@ -1,16 +1,17 @@
 package arrays;//: arrays/MultidimensionalObjectArrays.java
+
 import java.util.*;
 
 public class MultidimensionalObjectArrays {
     public static void main(String[] args) {
         BerylliumSphere[][] spheres = {
-      { new BerylliumSphere(), new BerylliumSphere() },
+                {new BerylliumSphere(), new BerylliumSphere()},
-      { new BerylliumSphere(), new BerylliumSphere(),
+                {new BerylliumSphere(), new BerylliumSphere(),
-        new BerylliumSphere(), new BerylliumSphere() },
+                        new BerylliumSphere(), new BerylliumSphere()},
-      { new BerylliumSphere(), new BerylliumSphere(),
+                {new BerylliumSphere(), new BerylliumSphere(),
                         new BerylliumSphere(), new BerylliumSphere(),
                         new BerylliumSphere(), new BerylliumSphere(),
-        new BerylliumSphere(), new BerylliumSphere() },
+                        new BerylliumSphere(), new BerylliumSphere()},
         };
         System.out.println(Arrays.deepToString(spheres));
     }

src/arrays/MultidimensionalPrimitiveArray.java

@@ -1,12 +1,13 @@
 package arrays;//: arrays/MultidimensionalPrimitiveArray.java
 // Creating multidimensional arrays.
+
 import java.util.*;
 
 public class MultidimensionalPrimitiveArray {
     public static void main(String[] args) {
         int[][] a = {
-      { 1, 2, 3, },
+                {1, 2, 3,},
-      { 4, 5, 6, },
+                {4, 5, 6,},
         };
         System.out.println(Arrays.deepToString(a));
     }

src/arrays/ParameterizedArrayType.java

@@ -1,17 +1,21 @@
 package arrays;//: arrays/ParameterizedArrayType.java
 
 class ClassParameter<T> {
-  public T[] f(T[] arg) { return arg; }
+    public T[] f(T[] arg) {
+        return arg;
+    }
 }
 
 class MethodParameter {
-  public static <T> T[] f(T[] arg) { return arg; }
+    public static <T> T[] f(T[] arg) {
+        return arg;
+    }
 }
 
 public class ParameterizedArrayType {
     public static void main(String[] args) {
-    Integer[] ints = { 1, 2, 3, 4, 5 };
+        Integer[] ints = {1, 2, 3, 4, 5};
-    Double[] doubles = { 1.1, 2.2, 3.3, 4.4, 5.5 };
+        Double[] doubles = {1.1, 2.2, 3.3, 4.4, 5.5};
         Integer[] ints2 =
                 new ClassParameter<Integer>().f(ints);
         Double[] doubles2 =

src/arrays/PrimitiveConversionDemonstration.java

@@ -1,5 +1,7 @@
 package arrays;//: arrays/PrimitiveConversionDemonstration.java
+
 import java.util.*;
+
 import net.mindview.util.*;
 
 public class PrimitiveConversionDemonstration {

src/arrays/RaggedArray.java

@@ -1,4 +1,5 @@
 package arrays;//: arrays/RaggedArray.java
+
 import java.util.*;
 
 public class RaggedArray {
@@ -6,9 +7,9 @@ public class RaggedArray {
         Random rand = new Random(47);
         // 3-D array with varied-length vectors:
         int[][][] a = new int[rand.nextInt(7)][][];
-    for(int i = 0; i < a.length; i++) {
+        for (int i = 0; i < a.length; i++) {
             a[i] = new int[rand.nextInt(5)][];
-      for(int j = 0; j < a[i].length; j++) {
+            for (int j = 0; j < a[i].length; j++) {
                 a[i][j] = new int[rand.nextInt(5)];
             }
         }

src/arrays/RandomGeneratorsTest.java

@@ -1,4 +1,5 @@
 package arrays;//: arrays/RandomGeneratorsTest.java
+
 import net.mindview.util.*;
 
 public class RandomGeneratorsTest {

src/arrays/Reverse.java

@@ -1,7 +1,10 @@
 package arrays;//: arrays/Reverse.java
 // The Collections.reverseOrder() Comparator
+
 import java.util.*;
+
 import net.mindview.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class Reverse {

src/arrays/StringSorting.java

@@ -1,7 +1,10 @@
 package arrays;//: arrays/StringSorting.java
 // Sorting an array of Strings.
+
 import java.util.*;
+
 import net.mindview.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class StringSorting {

src/arrays/TestArrayGeneration.java

@@ -1,7 +1,10 @@
 package arrays;//: arrays/TestArrayGeneration.java
 // Test the tools that use generators to fill arrays.
+
 import java.util.*;
+
 import net.mindview.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class TestArrayGeneration {

src/arrays/TestGenerated.java

@@ -1,12 +1,14 @@
 package arrays;//: arrays/TestGenerated.java
+
 import java.util.*;
+
 import net.mindview.util.*;
 
 public class TestGenerated {
     public static void main(String[] args) {
-    Integer[] a = { 9, 8, 7, 6 };
+        Integer[] a = {9, 8, 7, 6};
         System.out.println(Arrays.toString(a));
-    a = Generated.array(a,new CountingGenerator.Integer());
+        a = Generated.array(a, new CountingGenerator.Integer());
         System.out.println(Arrays.toString(a));
         Integer[] b = Generated.array(Integer.class,
                 new CountingGenerator.Integer(), 15);

src/arrays/ThreeDWithNew.java

@@ -1,4 +1,5 @@
 package arrays;//: arrays/ThreeDWithNew.java
+
 import java.util.*;
 
 public class ThreeDWithNew {

src/bangbean/BangBean.java

@@ -1,6 +1,7 @@
 //: bangbean/BangBean.java
 // A graphical Bean.
 package bangbean;
+
 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
@@ -15,68 +16,95 @@ BangBean extends JPanel implements Serializable {
     private int fontSize = 48;
     private Color tColor = Color.RED;
     private ActionListener actionListener;
+
     public BangBean() {
         addMouseListener(new ML());
         addMouseMotionListener(new MML());
     }
-  public int getCircleSize() { return cSize; }
+
+    public int getCircleSize() {
+        return cSize;
+    }
+
     public void setCircleSize(int newSize) {
         cSize = newSize;
     }
-  public String getBangText() { return text; }
+
+    public String getBangText() {
+        return text;
+    }
+
     public void setBangText(String newText) {
         text = newText;
     }
-  public int getFontSize() { return fontSize; }
+
+    public int getFontSize() {
+        return fontSize;
+    }
+
     public void setFontSize(int newSize) {
         fontSize = newSize;
     }
-  public Color getTextColor() { return tColor; }
+
+    public Color getTextColor() {
+        return tColor;
+    }
+
     public void setTextColor(Color newColor) {
         tColor = newColor;
     }
+
+    @Override
     public void paintComponent(Graphics g) {
         super.paintComponent(g);
         g.setColor(Color.BLACK);
-    g.drawOval(xm - cSize/2, ym - cSize/2, cSize, cSize);
+        g.drawOval(xm - cSize / 2, ym - cSize / 2, cSize, cSize);
     }
+
     // This is a unicast listener, which is
     // the simplest form of listener management:
     public void addActionListener(ActionListener l)
             throws TooManyListenersException {
-    if(actionListener != null) {
+        if (actionListener != null) {
             throw new TooManyListenersException();
         }
         actionListener = l;
     }
+
     public void removeActionListener(ActionListener l) {
         actionListener = null;
     }
+
     class ML extends MouseAdapter {
+        @Override
         public void mousePressed(MouseEvent e) {
             Graphics g = getGraphics();
             g.setColor(tColor);
             g.setFont(
                     new Font("TimesRoman", Font.BOLD, fontSize));
             int width = g.getFontMetrics().stringWidth(text);
-      g.drawString(text, (getSize().width - width) /2,
+            g.drawString(text, (getSize().width - width) / 2,
-        getSize().height/2);
+                    getSize().height / 2);
             g.dispose();
             // Call the listener's method:
-      if(actionListener != null) {
+            if (actionListener != null) {
                 actionListener.actionPerformed(
                         new ActionEvent(BangBean.this,
                                 ActionEvent.ACTION_PERFORMED, null));
             }
         }
     }
+
     class MML extends MouseMotionAdapter {
+        @Override
         public void mouseMoved(MouseEvent e) {
             xm = e.getX();
             ym = e.getY();
             repaint();
         }
     }
+
+    @Override
     public Dimension getPreferredSize() {
         return new Dimension(200, 200);
     }

src/bangbean/BangBeanTest.java

@@ -1,31 +1,38 @@
 //: bangbean/BangBeanTest.java
 // {Timeout: 5} Abort after 5 seconds when testing
 package bangbean;
+
 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.*;
 import java.util.*;
+
 import static net.mindview.util.SwingConsole.*;
 
 public class BangBeanTest extends JFrame {
     private JTextField txt = new JTextField(20);
+
     // During testing, report actions:
     class BBL implements ActionListener {
         private int count = 0;
+
+        @Override
         public void actionPerformed(ActionEvent e) {
-      txt.setText("BangBean action "+ count++);
+            txt.setText("BangBean action " + count++);
         }
     }
+
     public BangBeanTest() {
         BangBean bb = new BangBean();
         try {
             bb.addActionListener(new BBL());
-    } catch(TooManyListenersException e) {
+        } catch (TooManyListenersException e) {
             txt.setText("Too many listeners");
         }
         add(bb);
         add(BorderLayout.SOUTH, txt);
     }
+
     public static void main(String[] args) {
         run(new BangBeanTest(), 400, 500);
     }

src/concurrency/ActiveObjectDemo.java

@@ -2,27 +2,32 @@ package concurrency;//: concurrency/ActiveObjectDemo.java
 // Can only pass constants, immutables, "disconnected
 // objects," or other active objects as arguments
 // to asynch methods.
+
 import java.util.concurrent.*;
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class ActiveObjectDemo {
     private ExecutorService ex =
             Executors.newSingleThreadExecutor();
     private Random rand = new Random(47);
+
     // Insert a random delay to produce the effect
     // of a calculation time:
     private void pause(int factor) {
         try {
             TimeUnit.MILLISECONDS.sleep(
                     100 + rand.nextInt(factor));
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             print("sleep() interrupted");
         }
     }
+
     public Future<Integer>
     calculateInt(final int x, final int y) {
         return ex.submit(new Callable<Integer>() {
+            @Override
             public Integer call() {
                 print("starting " + x + " + " + y);
                 pause(500);
@@ -30,9 +35,11 @@ public class ActiveObjectDemo {
             }
         });
     }
+
     public Future<Float>
     calculateFloat(final float x, final float y) {
         return ex.submit(new Callable<Float>() {
+            @Override
             public Float call() {
                 print("starting " + x + " + " + y);
                 pause(2000);
@@ -40,25 +47,29 @@ public class ActiveObjectDemo {
             }
         });
     }
-  public void shutdown() { ex.shutdown(); }
+
+    public void shutdown() {
+        ex.shutdown();
+    }
+
     public static void main(String[] args) {
         ActiveObjectDemo d1 = new ActiveObjectDemo();
         // Prevents ConcurrentModificationException:
         List<Future<?>> results =
                 new CopyOnWriteArrayList<Future<?>>();
-    for(float f = 0.0f; f < 1.0f; f += 0.2f) {
+        for (float f = 0.0f; f < 1.0f; f += 0.2f) {
             results.add(d1.calculateFloat(f, f));
         }
-    for(int i = 0; i < 5; i++) {
+        for (int i = 0; i < 5; i++) {
             results.add(d1.calculateInt(i, i));
         }
         print("All asynch calls made");
-    while(results.size() > 0) {
+        while (results.size() > 0) {
-      for(Future<?> f : results) {
+            for (Future<?> f : results) {
-          if(f.isDone()) {
+                if (f.isDone()) {
                     try {
                         print(f.get());
-            } catch(Exception e) {
+                    } catch (Exception e) {
                         throw new RuntimeException(e);
                     }
                     results.remove(f);

src/concurrency/AtomicEvenGenerator.java

@@ -1,14 +1,18 @@
 package concurrency;//: concurrency/AtomicEvenGenerator.java
 // Atomic classes are occasionally useful in regular code.
 // {RunByHand}
+
 import java.util.concurrent.atomic.*;
 
 public class AtomicEvenGenerator extends IntGenerator {
     private AtomicInteger currentEvenValue =
             new AtomicInteger(0);
+
+    @Override
     public int next() {
         return currentEvenValue.addAndGet(2);
     }
+
     public static void main(String[] args) {
         EvenChecker.test(new AtomicEvenGenerator());
     }

src/concurrency/AtomicIntegerTest.java

@@ -1,19 +1,30 @@
 package concurrency;//: concurrency/AtomicIntegerTest.java
+
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 import java.util.*;
 
 public class AtomicIntegerTest implements Runnable {
     private AtomicInteger i = new AtomicInteger(0);
-  public int getValue() { return i.get(); }
+
-  private void evenIncrement() { i.addAndGet(2); }
+    public int getValue() {
+        return i.get();
+    }
+
+    private void evenIncrement() {
+        i.addAndGet(2);
+    }
+
+    @Override
     public void run() {
-    while(true) {
+        while (true) {
             evenIncrement();
         }
     }
+
     public static void main(String[] args) {
         new Timer().schedule(new TimerTask() {
+            @Override
             public void run() {
                 System.err.println("Aborting");
                 System.exit(0);
@@ -22,9 +33,9 @@ public class AtomicIntegerTest implements Runnable {
         ExecutorService exec = Executors.newCachedThreadPool();
         AtomicIntegerTest ait = new AtomicIntegerTest();
         exec.execute(ait);
-    while(true) {
+        while (true) {
             int val = ait.getValue();
-      if(val % 2 != 0) {
+            if (val % 2 != 0) {
                 System.out.println(val);
                 System.exit(0);
             }

src/concurrency/Atomicity.java

@@ -3,8 +3,14 @@ package concurrency;//: concurrency/Atomicity.java
 
 public class Atomicity {
     int i;
-  void f1() { i++; }
+
-  void f2() { i += 3; }
+    void f1() {
+        i++;
+    }
+
+    void f2() {
+        i += 3;
+    }
 } /* Output: (Sample)
 ...
 void f1();

src/concurrency/AtomicityTest.java

@@ -1,22 +1,33 @@
 package concurrency;//: concurrency/AtomicityTest.java
+
 import java.util.concurrent.*;
 
 public class AtomicityTest implements Runnable {
     private int i = 0;
-  public int getValue() { return i; }
+
-  private synchronized void evenIncrement() { i++; i++; }
+    public int getValue() {
+        return i;
+    }
+
+    private synchronized void evenIncrement() {
+        i++;
+        i++;
+    }
+
+    @Override
     public void run() {
-    while(true) {
+        while (true) {
             evenIncrement();
         }
     }
+
     public static void main(String[] args) {
         ExecutorService exec = Executors.newCachedThreadPool();
         AtomicityTest at = new AtomicityTest();
         exec.execute(at);
-    while(true) {
+        while (true) {
             int val = at.getValue();
-      if(val % 2 != 0) {
+            if (val % 2 != 0) {
                 System.out.println(val);
                 System.exit(0);
             }

src/concurrency/AttemptLocking.java

@@ -1,44 +1,52 @@
 package concurrency;//: concurrency/AttemptLocking.java
 // Locks in the concurrent library allow you
 // to give up on trying to acquire a lock.
+
 import java.util.concurrent.*;
 import java.util.concurrent.locks.*;
 
 public class AttemptLocking {
     private ReentrantLock lock = new ReentrantLock();
+
     public void untimed() {
         boolean captured = lock.tryLock();
         try {
             System.out.println("tryLock(): " + captured);
         } finally {
-      if(captured) {
+            if (captured) {
                 lock.unlock();
             }
         }
     }
+
     public void timed() {
         boolean captured = false;
         try {
             captured = lock.tryLock(2, TimeUnit.SECONDS);
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             throw new RuntimeException(e);
         }
         try {
             System.out.println("tryLock(2, TimeUnit.SECONDS): " +
                     captured);
         } finally {
-      if(captured) {
+            if (captured) {
                 lock.unlock();
             }
         }
     }
+
     public static void main(String[] args) {
         final AttemptLocking al = new AttemptLocking();
         al.untimed(); // True -- lock is available
         al.timed();   // True -- lock is available
         // Now create a separate task to grab the lock:
         new Thread() {
-      { setDaemon(true); }
+            {
+                setDaemon(true);
+            }
+
+            @Override
             public void run() {
                 al.lock.lock();
                 System.out.println("acquired");

src/concurrency/BankTellerSimulation.java

@@ -1,14 +1,23 @@
 package concurrency;//: concurrency/BankTellerSimulation.java
 // Using queues and multithreading.
 // {Args: 5}
+
 import java.util.concurrent.*;
 import java.util.*;
 
 // Read-only objects don't require synchronization:
 class Customer {
     private final int serviceTime;
-  public Customer(int tm) { serviceTime = tm; }
+
-  public int getServiceTime() { return serviceTime; }
+    public Customer(int tm) {
+        serviceTime = tm;
+    }
+
+    public int getServiceTime() {
+        return serviceTime;
+    }
+
+    @Override
     public String toString() {
         return "[" + serviceTime + "]";
     }
@@ -19,12 +28,14 @@ class CustomerLine extends ArrayBlockingQueue<Customer> {
     public CustomerLine(int maxLineSize) {
         super(maxLineSize);
     }
+
+    @Override
     public String toString() {
-    if(this.size() == 0) {
+        if (this.size() == 0) {
             return "[Empty]";
         }
         StringBuilder result = new StringBuilder();
-    for(Customer customer : this) {
+        for (Customer customer : this) {
             result.append(customer);
         }
         return result.toString();
@@ -35,16 +46,19 @@ class CustomerLine extends ArrayBlockingQueue<Customer> {
 class CustomerGenerator implements Runnable {
     private CustomerLine customers;
     private static Random rand = new Random(47);
+
     public CustomerGenerator(CustomerLine cq) {
         customers = cq;
     }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 TimeUnit.MILLISECONDS.sleep(rand.nextInt(300));
                 customers.put(new Customer(rand.nextInt(1000)));
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             System.out.println("CustomerGenerator interrupted");
         }
         System.out.println("CustomerGenerator terminating");
@@ -58,37 +72,53 @@ class Teller implements Runnable, Comparable<Teller> {
     private int customersServed = 0;
     private CustomerLine customers;
     private boolean servingCustomerLine = true;
-  public Teller(CustomerLine cq) { customers = cq; }
+
+    public Teller(CustomerLine cq) {
+        customers = cq;
+    }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 Customer customer = customers.take();
                 TimeUnit.MILLISECONDS.sleep(
                         customer.getServiceTime());
-        synchronized(this) {
+                synchronized (this) {
                     customersServed++;
-          while(!servingCustomerLine) {
+                    while (!servingCustomerLine) {
                         wait();
                     }
                 }
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             System.out.println(this + "interrupted");
         }
         System.out.println(this + "terminating");
     }
+
     public synchronized void doSomethingElse() {
         customersServed = 0;
         servingCustomerLine = false;
     }
+
     public synchronized void serveCustomerLine() {
-    assert !servingCustomerLine:"already serving: " + this;
+        assert !servingCustomerLine : "already serving: " + this;
         servingCustomerLine = true;
         notifyAll();
     }
-  public String toString() { return "Teller " + id + " "; }
+
-  public String shortString() { return "T" + id; }
+    @Override
+    public String toString() {
+        return "Teller " + id + " ";
+    }
+
+    public String shortString() {
+        return "T" + id;
+    }
+
     // Used by priority queue:
+    @Override
     public synchronized int compareTo(Teller other) {
         return customersServed < other.customersServed ? -1 :
                 (customersServed == other.customersServed ? 0 : 1);
@@ -104,6 +134,7 @@ class TellerManager implements Runnable {
             new LinkedList<Teller>();
     private int adjustmentPeriod;
     private static Random rand = new Random(47);
+
     public TellerManager(ExecutorService e,
                          CustomerLine customers, int adjustmentPeriod) {
         exec = e;
@@ -114,15 +145,16 @@ class TellerManager implements Runnable {
         exec.execute(teller);
         workingTellers.add(teller);
     }
+
     public void adjustTellerNumber() {
         // This is actually a control system. By adjusting
         // the numbers, you can reveal stability issues in
         // the control mechanism.
         // If line is too long, add another teller:
-    if(customers.size() / workingTellers.size() > 2) {
+        if (customers.size() / workingTellers.size() > 2) {
             // If tellers are on break or doing
             // another job, bring one back:
-        if(tellersDoingOtherThings.size() > 0) {
+            if (tellersDoingOtherThings.size() > 0) {
                 Teller teller = tellersDoingOtherThings.remove();
                 teller.serveCustomerLine();
                 workingTellers.offer(teller);
@@ -135,45 +167,53 @@ class TellerManager implements Runnable {
             return;
         }
         // If line is short enough, remove a teller:
-    if(workingTellers.size() > 1 &&
+        if (workingTellers.size() > 1 &&
                 customers.size() / workingTellers.size() < 2) {
             reassignOneTeller();
         }
         // If there is no line, we only need one teller:
-    if(customers.size() == 0) {
+        if (customers.size() == 0) {
-        while(workingTellers.size() > 1) {
+            while (workingTellers.size() > 1) {
                 reassignOneTeller();
             }
         }
     }
+
     // Give a teller a different job or a break:
     private void reassignOneTeller() {
         Teller teller = workingTellers.poll();
         teller.doSomethingElse();
         tellersDoingOtherThings.offer(teller);
     }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 TimeUnit.MILLISECONDS.sleep(adjustmentPeriod);
                 adjustTellerNumber();
                 System.out.print(customers + " { ");
-        for(Teller teller : workingTellers) {
+                for (Teller teller : workingTellers) {
                     System.out.print(teller.shortString() + " ");
                 }
                 System.out.println("}");
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             System.out.println(this + "interrupted");
         }
         System.out.println(this + "terminating");
     }
-  public String toString() { return "TellerManager "; }
+
+    @Override
+    public String toString() {
+        return "TellerManager ";
+    }
 }
 
 public class BankTellerSimulation {
     static final int MAX_LINE_SIZE = 50;
     static final int ADJUSTMENT_PERIOD = 1000;
+
     public static void main(String[] args) throws Exception {
         ExecutorService exec = Executors.newCachedThreadPool();
         // If line is too long, customers will leave:
@@ -183,7 +223,7 @@ public class BankTellerSimulation {
         // Manager will add and remove tellers as necessary:
         exec.execute(new TellerManager(
                 exec, customers, ADJUSTMENT_PERIOD));
-    if(args.length > 0) // Optional argument
+        if (args.length > 0) // Optional argument
         {
             TimeUnit.SECONDS.sleep(new Integer(args[0]));
         } else {

src/concurrency/CachedThreadPool.java

@@ -1,10 +1,11 @@
 package concurrency;//: concurrency/CachedThreadPool.java
+
 import java.util.concurrent.*;
 
 public class CachedThreadPool {
     public static void main(String[] args) {
         ExecutorService exec = Executors.newCachedThreadPool();
-    for(int i = 0; i < 5; i++) {
+        for (int i = 0; i < 5; i++) {
             exec.execute(new LiftOff());
         }
         exec.shutdown();

src/concurrency/CallableDemo.java

@@ -1,12 +1,16 @@
 package concurrency;//: concurrency/CallableDemo.java
+
 import java.util.concurrent.*;
 import java.util.*;
 
 class TaskWithResult implements Callable<String> {
     private int id;
+
     public TaskWithResult(int id) {
         this.id = id;
     }
+
+    @Override
     public String call() {
         return "result of TaskWithResult " + id;
     }
@@ -17,17 +21,17 @@ public class CallableDemo {
         ExecutorService exec = Executors.newCachedThreadPool();
         ArrayList<Future<String>> results =
                 new ArrayList<Future<String>>();
-    for(int i = 0; i < 10; i++) {
+        for (int i = 0; i < 10; i++) {
             results.add(exec.submit(new TaskWithResult(i)));
         }
-    for(Future<String> fs : results) {
+        for (Future<String> fs : results) {
             try {
                 // get() blocks until completion:
                 System.out.println(fs.get());
-        } catch(InterruptedException e) {
+            } catch (InterruptedException e) {
                 System.out.println(e);
                 return;
-        } catch(ExecutionException e) {
+            } catch (ExecutionException e) {
                 System.out.println(e);
             } finally {
                 exec.shutdown();

src/concurrency/CaptureUncaughtException.java

@@ -1,7 +1,9 @@
 package concurrency;//: concurrency/CaptureUncaughtException.java
+
 import java.util.concurrent.*;
 
 class ExceptionThread2 implements Runnable {
+    @Override
     public void run() {
         Thread t = Thread.currentThread();
         System.out.println("run() by " + t);
@@ -12,13 +14,15 @@ class ExceptionThread2 implements Runnable {
 }
 
 class MyUncaughtExceptionHandler implements
-Thread.UncaughtExceptionHandler {
+        Thread.UncaughtExceptionHandler {
+    @Override
     public void uncaughtException(Thread t, Throwable e) {
         System.out.println("caught " + e);
     }
 }
 
 class HandlerThreadFactory implements ThreadFactory {
+    @Override
     public Thread newThread(Runnable r) {
         System.out.println(this + " creating new Thread");
         Thread t = new Thread(r);

src/concurrency/CarBuilder.java

@@ -1,22 +1,42 @@
 package concurrency;//: concurrency/CarBuilder.java
 // A complex example of tasks working together.
+
 import java.util.concurrent.*;
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 class Car {
     private final int id;
     private boolean
             engine = false, driveTrain = false, wheels = false;
-  public Car(int idn)  { id = idn; }
+
+    public Car(int idn) {
+        id = idn;
+    }
+
     // Empty Car object:
-  public Car()  { id = -1; }
+    public Car() {
-  public synchronized int getId() { return id; }
+        id = -1;
-  public synchronized void addEngine() { engine = true; }
+    }
+
+    public synchronized int getId() {
+        return id;
+    }
+
+    public synchronized void addEngine() {
+        engine = true;
+    }
+
     public synchronized void addDriveTrain() {
         driveTrain = true;
     }
-  public synchronized void addWheels() { wheels = true; }
+
+    public synchronized void addWheels() {
+        wheels = true;
+    }
+
+    @Override
     public synchronized String toString() {
         return "Car " + id + " [" + " engine: " + engine
                 + " driveTrain: " + driveTrain
@@ -24,15 +44,21 @@ class Car {
     }
 }
 
-class CarQueue extends LinkedBlockingQueue<Car> {}
+class CarQueue extends LinkedBlockingQueue<Car> {
+}
 
 class ChassisBuilder implements Runnable {
     private CarQueue carQueue;
     private int counter = 0;
-  public ChassisBuilder(CarQueue cq) { carQueue = cq; }
+
+    public ChassisBuilder(CarQueue cq) {
+        carQueue = cq;
+    }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 TimeUnit.MILLISECONDS.sleep(500);
                 // Make chassis:
                 Car c = new Car(counter++);
@@ -40,7 +66,7 @@ class ChassisBuilder implements Runnable {
                 // Insert into queue
                 carQueue.put(c);
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             print("Interrupted: ChassisBuilder");
         }
         print("ChassisBuilder off");
@@ -52,16 +78,25 @@ class Assembler implements Runnable {
     private Car car;
     private CyclicBarrier barrier = new CyclicBarrier(4);
     private RobotPool robotPool;
-  public Assembler(CarQueue cq, CarQueue fq, RobotPool rp){
+
+    public Assembler(CarQueue cq, CarQueue fq, RobotPool rp) {
         chassisQueue = cq;
         finishingQueue = fq;
         robotPool = rp;
     }
-  public Car car() { return car; }
+
-  public CyclicBarrier barrier() { return barrier; }
+    public Car car() {
+        return car;
+    }
+
+    public CyclicBarrier barrier() {
+        return barrier;
+    }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 // Blocks until chassis is available:
                 car = chassisQueue.take();
                 // Hire robots to perform work:
@@ -72,9 +107,9 @@ class Assembler implements Runnable {
                 // Put car into finishingQueue for further work
                 finishingQueue.put(car);
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             print("Exiting Assembler via interrupt");
-    } catch(BrokenBarrierException e) {
+        } catch (BrokenBarrierException e) {
             // This one we want to know about
             throw new RuntimeException(e);
         }
@@ -84,13 +119,18 @@ class Assembler implements Runnable {
 
 class Reporter implements Runnable {
     private CarQueue carQueue;
-  public Reporter(CarQueue cq) { carQueue = cq; }
+
+    public Reporter(CarQueue cq) {
+        carQueue = cq;
+    }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 print(carQueue.take());
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             print("Exiting Reporter via interrupt");
         }
         print("Reporter off");
@@ -99,52 +139,71 @@ class Reporter implements Runnable {
 
 abstract class Robot implements Runnable {
     private RobotPool pool;
-  public Robot(RobotPool p) { pool = p; }
+
+    public Robot(RobotPool p) {
+        pool = p;
+    }
+
     protected Assembler assembler;
+
     public Robot assignAssembler(Assembler assembler) {
         this.assembler = assembler;
         return this;
     }
+
     private boolean engage = false;
+
     public synchronized void engage() {
         engage = true;
         notifyAll();
     }
+
     // The part of run() that's different for each robot:
     abstract protected void performService();
+
+    @Override
     public void run() {
         try {
             powerDown(); // Wait until needed
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 performService();
                 assembler.barrier().await(); // Synchronize
                 // We're done with that job...
                 powerDown();
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             print("Exiting " + this + " via interrupt");
-    } catch(BrokenBarrierException e) {
+        } catch (BrokenBarrierException e) {
             // This one we want to know about
             throw new RuntimeException(e);
         }
         print(this + " off");
     }
+
     private synchronized void
     powerDown() throws InterruptedException {
         engage = false;
         assembler = null; // Disconnect from the Assembler
         // Put ourselves back in the available pool:
         pool.release(this);
-    while(engage == false)  // Power down
+        while (engage == false)  // Power down
         {
             wait();
         }
     }
-  public String toString() { return getClass().getName(); }
+
+    @Override
+    public String toString() {
+        return getClass().getName();
+    }
 }
 
 class EngineRobot extends Robot {
-  public EngineRobot(RobotPool pool) { super(pool); }
+    public EngineRobot(RobotPool pool) {
+        super(pool);
+    }
+
+    @Override
     protected void performService() {
         print(this + " installing engine");
         assembler.car().addEngine();
@@ -152,7 +211,11 @@ class EngineRobot extends Robot {
 }
 
 class DriveTrainRobot extends Robot {
-  public DriveTrainRobot(RobotPool pool) { super(pool); }
+    public DriveTrainRobot(RobotPool pool) {
+        super(pool);
+    }
+
+    @Override
     protected void performService() {
         print(this + " installing DriveTrain");
         assembler.car().addDriveTrain();
@@ -160,7 +223,11 @@ class DriveTrainRobot extends Robot {
 }
 
 class WheelRobot extends Robot {
-  public WheelRobot(RobotPool pool) { super(pool); }
+    public WheelRobot(RobotPool pool) {
+        super(pool);
+    }
+
+    @Override
     protected void performService() {
         print(this + " installing Wheels");
         assembler.car().addWheels();
@@ -170,15 +237,17 @@ class WheelRobot extends Robot {
 class RobotPool {
     // Quietly prevents identical entries:
     private Set<Robot> pool = new HashSet<Robot>();
+
     public synchronized void add(Robot r) {
         pool.add(r);
         notifyAll();
     }
+
     public synchronized void
     hire(Class<? extends Robot> robotType, Assembler d)
             throws InterruptedException {
-    for(Robot r : pool) {
+        for (Robot r : pool) {
-        if(r.getClass().equals(robotType)) {
+            if (r.getClass().equals(robotType)) {
                 pool.remove(r);
                 r.assignAssembler(d);
                 r.engage(); // Power it up to do the task
@@ -188,7 +257,10 @@ class RobotPool {
         wait(); // None available
         hire(robotType, d); // Try again, recursively
     }
-  public synchronized void release(Robot r) { add(r); }
+
+    public synchronized void release(Robot r) {
+        add(r);
+    }
 }
 
 public class CarBuilder {

src/concurrency/Chopstick.java

@@ -3,13 +3,14 @@ package concurrency;//: concurrency/Chopstick.java
 
 public class Chopstick {
     private boolean taken = false;
-  public synchronized
+
-  void take() throws InterruptedException {
+    public synchronized void take() throws InterruptedException {
-    while(taken) {
+        while (taken) {
             wait();
         }
         taken = true;
     }
+
     public synchronized void drop() {
         taken = false;
         notifyAll();

src/concurrency/CloseResource.java

@@ -2,9 +2,11 @@ package concurrency;//: concurrency/CloseResource.java
 // Interrupting a blocked task by
 // closing the underlying resource.
 // {RunByHand}
+
 import java.net.*;
 import java.util.concurrent.*;
 import java.io.*;
+
 import static net.mindview.util.Print.*;
 
 public class CloseResource {

src/concurrency/CountDownLatchDemo.java

@@ -1,6 +1,8 @@
 package concurrency;//: concurrency/CountDownLatchDemo.java
+
 import java.util.concurrent.*;
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 // Performs some portion of a task:
@@ -9,21 +11,27 @@ class TaskPortion implements Runnable {
     private final int id = counter++;
     private static Random rand = new Random(47);
     private final CountDownLatch latch;
+
     TaskPortion(CountDownLatch latch) {
         this.latch = latch;
     }
+
+    @Override
     public void run() {
         try {
             doWork();
             latch.countDown();
-    } catch(InterruptedException ex) {
+        } catch (InterruptedException ex) {
             // Acceptable way to exit
         }
     }
+
     public void doWork() throws InterruptedException {
         TimeUnit.MILLISECONDS.sleep(rand.nextInt(2000));
         print(this + "completed");
     }
+
+    @Override
     public String toString() {
         return String.format("%1$-3d ", id);
     }
@@ -34,17 +42,22 @@ class WaitingTask implements Runnable {
     private static int counter = 0;
     private final int id = counter++;
     private final CountDownLatch latch;
+
     WaitingTask(CountDownLatch latch) {
         this.latch = latch;
     }
+
+    @Override
     public void run() {
         try {
             latch.await();
             print("Latch barrier passed for " + this);
-    } catch(InterruptedException ex) {
+        } catch (InterruptedException ex) {
             print(this + " interrupted");
         }
     }
+
+    @Override
     public String toString() {
         return String.format("WaitingTask %1$-3d ", id);
     }
@@ -52,14 +65,15 @@ class WaitingTask implements Runnable {
 
 public class CountDownLatchDemo {
     static final int SIZE = 100;
+
     public static void main(String[] args) throws Exception {
         ExecutorService exec = Executors.newCachedThreadPool();
         // All must share a single CountDownLatch object:
         CountDownLatch latch = new CountDownLatch(SIZE);
-    for(int i = 0; i < 10; i++) {
+        for (int i = 0; i < 10; i++) {
             exec.execute(new WaitingTask(latch));
         }
-    for(int i = 0; i < SIZE; i++) {
+        for (int i = 0; i < SIZE; i++) {
             exec.execute(new TaskPortion(latch));
         }
         print("Launched all tasks");

src/concurrency/CriticalSection.java

@@ -3,33 +3,54 @@
 // demonstrates protection of a non-thread-safe class
 // with a thread-safe one.
 package concurrency;
+
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 import java.util.*;
 
 class Pair { // Not thread-safe
     private int x, y;
+
     public Pair(int x, int y) {
         this.x = x;
         this.y = y;
     }
-  public Pair() { this(0, 0); }
+
-  public int getX() { return x; }
+    public Pair() {
-  public int getY() { return y; }
+        this(0, 0);
-  public void incrementX() { x++; }
+    }
-  public void incrementY() { y++; }
+
+    public int getX() {
+        return x;
+    }
+
+    public int getY() {
+        return y;
+    }
+
+    public void incrementX() {
+        x++;
+    }
+
+    public void incrementY() {
+        y++;
+    }
+
+    @Override
     public String toString() {
         return "x: " + x + ", y: " + y;
     }
+
     public class PairValuesNotEqualException
             extends RuntimeException {
         public PairValuesNotEqualException() {
             super("Pair values not equal: " + Pair.this);
         }
     }
+
     // Arbitrary invariant -- both variables must be equal:
     public void checkState() {
-    if(x != y) {
+        if (x != y) {
             throw new PairValuesNotEqualException();
         }
     }
@@ -41,22 +62,27 @@ abstract class PairManager {
     protected Pair p = new Pair();
     private List<Pair> storage =
             Collections.synchronizedList(new ArrayList<Pair>());
+
     public synchronized Pair getPair() {
         // Make a copy to keep the original safe:
         return new Pair(p.getX(), p.getY());
     }
+
     // Assume this is a time consuming operation
     protected void store(Pair p) {
         storage.add(p);
         try {
             TimeUnit.MILLISECONDS.sleep(50);
-    } catch(InterruptedException ignore) {}
+        } catch (InterruptedException ignore) {
         }
+    }
+
     public abstract void increment();
 }
 
 // Synchronize the entire method:
 class PairManager1 extends PairManager {
+    @Override
     public synchronized void increment() {
         p.incrementX();
         p.incrementY();
@@ -66,9 +92,10 @@ class PairManager1 extends PairManager {
 
 // Use a critical section:
 class PairManager2 extends PairManager {
+    @Override
     public void increment() {
         Pair temp;
-    synchronized(this) {
+        synchronized (this) {
             p.incrementX();
             p.incrementY();
             temp = getPair();
@@ -79,14 +106,19 @@ class PairManager2 extends PairManager {
 
 class PairManipulator implements Runnable {
     private PairManager pm;
+
     public PairManipulator(PairManager pm) {
         this.pm = pm;
     }
+
+    @Override
     public void run() {
-    while(true) {
+        while (true) {
             pm.increment();
         }
     }
+
+    @Override
     public String toString() {
         return "Pair: " + pm.getPair() +
                 " checkCounter = " + pm.checkCounter.get();
@@ -95,11 +127,14 @@ class PairManipulator implements Runnable {
 
 class PairChecker implements Runnable {
     private PairManager pm;
+
     public PairChecker(PairManager pm) {
         this.pm = pm;
     }
+
+    @Override
     public void run() {
-    while(true) {
+        while (true) {
             pm.checkCounter.incrementAndGet();
             pm.getPair().checkState();
         }
@@ -123,12 +158,13 @@ public class CriticalSection {
         exec.execute(pcheck2);
         try {
             TimeUnit.MILLISECONDS.sleep(500);
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             System.out.println("Sleep interrupted");
         }
         System.out.println("pm1: " + pm1 + "\npm2: " + pm2);
         System.exit(0);
     }
+
     public static void main(String[] args) {
         PairManager
                 pman1 = new PairManager1(),

src/concurrency/DaemonFromFactory.java

@@ -1,24 +1,29 @@
 package concurrency;//: concurrency/DaemonFromFactory.java
 // Using a Thread Factory to create daemons.
+
 import java.util.concurrent.*;
+
 import net.mindview.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class DaemonFromFactory implements Runnable {
+    @Override
     public void run() {
         try {
-      while(true) {
+            while (true) {
                 TimeUnit.MILLISECONDS.sleep(100);
                 print(Thread.currentThread() + " " + this);
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             print("Interrupted");
         }
     }
+
     public static void main(String[] args) throws Exception {
         ExecutorService exec = Executors.newCachedThreadPool(
                 new DaemonThreadFactory());
-    for(int i = 0; i < 10; i++) {
+        for (int i = 0; i < 10; i++) {
             exec.execute(new DaemonFromFactory());
         }
         print("All daemons started");

src/concurrency/Daemons.java

@@ -1,29 +1,34 @@
 package concurrency;//: concurrency/Daemons.java
 // Daemon threads spawn other daemon threads.
+
 import java.util.concurrent.*;
+
 import static net.mindview.util.Print.*;
 
 class Daemon implements Runnable {
     private Thread[] t = new Thread[10];
+
+    @Override
     public void run() {
-    for(int i = 0; i < t.length; i++) {
+        for (int i = 0; i < t.length; i++) {
             t[i] = new Thread(new DaemonSpawn());
             t[i].start();
             printnb("DaemonSpawn " + i + " started, ");
         }
-    for(int i = 0; i < t.length; i++) {
+        for (int i = 0; i < t.length; i++) {
             printnb("t[" + i + "].isDaemon() = " +
                     t[i].isDaemon() + ", ");
         }
-    while(true) {
+        while (true) {
             Thread.yield();
         }
     }
 }
 
 class DaemonSpawn implements Runnable {
+    @Override
     public void run() {
-    while(true) {
+        while (true) {
             Thread.yield();
         }
     }

src/concurrency/DaemonsDontRunFinally.java

@@ -1,14 +1,17 @@
 package concurrency;//: concurrency/DaemonsDontRunFinally.java
 // Daemon threads don't run the finally clause
+
 import java.util.concurrent.*;
+
 import static net.mindview.util.Print.*;
 
 class ADaemon implements Runnable {
+    @Override
     public void run() {
         try {
             print("Starting ADaemon");
             TimeUnit.SECONDS.sleep(1);
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             print("Exiting via InterruptedException");
         } finally {
             print("This should always run?");

src/concurrency/DeadlockingDiningPhilosophers.java

@@ -1,28 +1,29 @@
 package concurrency;//: concurrency/DeadlockingDiningPhilosophers.java
 // Demonstrates how deadlock can be hidden in a program.
 // {Args: 0 5 timeout}
+
 import java.util.concurrent.*;
 
 public class DeadlockingDiningPhilosophers {
     public static void main(String[] args) throws Exception {
         int ponder = 5;
-    if(args.length > 0) {
+        if (args.length > 0) {
             ponder = Integer.parseInt(args[0]);
         }
         int size = 5;
-    if(args.length > 1) {
+        if (args.length > 1) {
             size = Integer.parseInt(args[1]);
         }
         ExecutorService exec = Executors.newCachedThreadPool();
         Chopstick[] sticks = new Chopstick[size];
-    for(int i = 0; i < size; i++) {
+        for (int i = 0; i < size; i++) {
             sticks[i] = new Chopstick();
         }
-    for(int i = 0; i < size; i++) {
+        for (int i = 0; i < size; i++) {
             exec.execute(new Philosopher(
-          sticks[i], sticks[(i+1) % size], i, ponder));
+                    sticks[i], sticks[(i + 1) % size], i, ponder));
         }
-    if(args.length == 3 && args[2].equals("timeout")) {
+        if (args.length == 3 && args[2].equals("timeout")) {
             TimeUnit.SECONDS.sleep(5);
         } else {
             System.out.println("Press 'Enter' to quit");

src/concurrency/DelayQueueDemo.java

@@ -1,6 +1,8 @@
 package concurrency;//: concurrency/DelayQueueDemo.java
+
 import java.util.concurrent.*;
 import java.util.*;
+
 import static java.util.concurrent.TimeUnit.*;
 import static net.mindview.util.Print.*;
 
@@ -11,42 +13,58 @@ class DelayedTask implements Runnable, Delayed {
     private final long trigger;
     protected static List<DelayedTask> sequence =
             new ArrayList<DelayedTask>();
+
     public DelayedTask(int delayInMilliseconds) {
         delta = delayInMilliseconds;
         trigger = System.nanoTime() +
                 NANOSECONDS.convert(delta, MILLISECONDS);
         sequence.add(this);
     }
+
+    @Override
     public long getDelay(TimeUnit unit) {
         return unit.convert(
                 trigger - System.nanoTime(), NANOSECONDS);
     }
+
+    @Override
     public int compareTo(Delayed arg) {
-    DelayedTask that = (DelayedTask)arg;
+        DelayedTask that = (DelayedTask) arg;
-    if(trigger < that.trigger) {
+        if (trigger < that.trigger) {
             return -1;
         }
-    if(trigger > that.trigger) {
+        if (trigger > that.trigger) {
             return 1;
         }
         return 0;
     }
-  public void run() { printnb(this + " "); }
+
+    @Override
+    public void run() {
+        printnb(this + " ");
+    }
+
+    @Override
     public String toString() {
         return String.format("[%1$-4d]", delta) +
                 " Task " + id;
     }
+
     public String summary() {
         return "(" + id + ":" + delta + ")";
     }
+
     public static class EndSentinel extends DelayedTask {
         private ExecutorService exec;
+
         public EndSentinel(int delay, ExecutorService e) {
             super(delay);
             exec = e;
         }
+
+        @Override
         public void run() {
-      for(DelayedTask pt : sequence) {
+            for (DelayedTask pt : sequence) {
                 printnb(pt.summary() + " ");
             }
             print();
@@ -58,15 +76,18 @@ class DelayedTask implements Runnable, Delayed {
 
 class DelayedTaskConsumer implements Runnable {
     private DelayQueue<DelayedTask> q;
+
     public DelayedTaskConsumer(DelayQueue<DelayedTask> q) {
         this.q = q;
     }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 q.take().run(); // Run task with the current thread
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             // Acceptable way to exit
         }
         print("Finished DelayedTaskConsumer");
@@ -80,7 +101,7 @@ public class DelayQueueDemo {
         DelayQueue<DelayedTask> queue =
                 new DelayQueue<DelayedTask>();
         // Fill with tasks that have random delays:
-    for(int i = 0; i < 20; i++) {
+        for (int i = 0; i < 20; i++) {
             queue.put(new DelayedTask(rand.nextInt(5000)));
         }
         // Set the stopping point

src/concurrency/EvenChecker.java

@@ -1,31 +1,37 @@
 package concurrency;//: concurrency/EvenChecker.java
+
 import java.util.concurrent.*;
 
 public class EvenChecker implements Runnable {
     private IntGenerator generator;
     private final int id;
+
     public EvenChecker(IntGenerator g, int ident) {
         generator = g;
         id = ident;
     }
+
+    @Override
     public void run() {
-    while(!generator.isCanceled()) {
+        while (!generator.isCanceled()) {
             int val = generator.next();
-      if(val % 2 != 0) {
+            if (val % 2 != 0) {
                 System.out.println(val + " not even!");
                 generator.cancel(); // Cancels all EvenCheckers
             }
         }
     }
+
     // Test any type of IntGenerator:
     public static void test(IntGenerator gp, int count) {
         System.out.println("Press Control-C to exit");
         ExecutorService exec = Executors.newCachedThreadPool();
-    for(int i = 0; i < count; i++) {
+        for (int i = 0; i < count; i++) {
             exec.execute(new EvenChecker(gp, i));
         }
         exec.shutdown();
     }
+
     // Default value for count:
     public static void test(IntGenerator gp) {
         test(gp, 10);

src/concurrency/EvenGenerator.java

@@ -3,11 +3,14 @@ package concurrency;//: concurrency/EvenGenerator.java
 
 public class EvenGenerator extends IntGenerator {
     private int currentEvenValue = 0;
+
+    @Override
     public int next() {
         ++currentEvenValue; // Danger point here!
         ++currentEvenValue;
         return currentEvenValue;
     }
+
     public static void main(String[] args) {
         EvenChecker.test(new EvenGenerator());
     }

src/concurrency/ExceptionThread.java

@@ -1,11 +1,14 @@
 package concurrency;//: concurrency/ExceptionThread.java
 // {ThrowsException}
+
 import java.util.concurrent.*;
 
 public class ExceptionThread implements Runnable {
+    @Override
     public void run() {
         throw new RuntimeException();
     }
+
     public static void main(String[] args) {
         ExecutorService exec = Executors.newCachedThreadPool();
         exec.execute(new ExceptionThread());

src/concurrency/ExchangerDemo.java

@@ -1,28 +1,33 @@
 package concurrency;//: concurrency/ExchangerDemo.java
+
 import java.util.concurrent.*;
 import java.util.*;
+
 import net.mindview.util.*;
 
 class ExchangerProducer<T> implements Runnable {
     private Generator<T> generator;
     private Exchanger<List<T>> exchanger;
     private List<T> holder;
+
     ExchangerProducer(Exchanger<List<T>> exchg,
                       Generator<T> gen, List<T> holder) {
         exchanger = exchg;
         generator = gen;
         this.holder = holder;
     }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
-        for(int i = 0; i < ExchangerDemo.size; i++) {
+                for (int i = 0; i < ExchangerDemo.size; i++) {
                     holder.add(generator.next());
                 }
                 // Exchange full for empty:
                 holder = exchanger.exchange(holder);
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             // OK to terminate this way.
         }
     }
@@ -32,20 +37,23 @@ class ExchangerConsumer<T> implements Runnable {
     private Exchanger<List<T>> exchanger;
     private List<T> holder;
     private volatile T value;
-  ExchangerConsumer(Exchanger<List<T>> ex, List<T> holder){
+
+    ExchangerConsumer(Exchanger<List<T>> ex, List<T> holder) {
         exchanger = ex;
         this.holder = holder;
     }
+
+    @Override
     public void run() {
         try {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 holder = exchanger.exchange(holder);
-        for(T x : holder) {
+                for (T x : holder) {
                     value = x; // Fetch out value
                     holder.remove(x); // OK for CopyOnWriteArrayList
                 }
             }
-    } catch(InterruptedException e) {
+        } catch (InterruptedException e) {
             // OK to terminate this way.
         }
         System.out.println("Final value: " + value);
@@ -55,11 +63,12 @@ class ExchangerConsumer<T> implements Runnable {
 public class ExchangerDemo {
     static int size = 10;
     static int delay = 5; // Seconds
+
     public static void main(String[] args) throws Exception {
-    if(args.length > 0) {
+        if (args.length > 0) {
             size = new Integer(args[0]);
         }
-    if(args.length > 1) {
+        if (args.length > 1) {
             delay = new Integer(args[1]);
         }
         ExecutorService exec = Executors.newCachedThreadPool();
@@ -70,7 +79,7 @@ public class ExchangerDemo {
         exec.execute(new ExchangerProducer<Fat>(xc,
                 BasicGenerator.create(Fat.class), producerList));
         exec.execute(
-      new ExchangerConsumer<Fat>(xc,consumerList));
+                new ExchangerConsumer<Fat>(xc, consumerList));
         TimeUnit.SECONDS.sleep(delay);
         exec.shutdownNow();
     }

src/concurrency/ExplicitCriticalSection.java

@@ -1,11 +1,14 @@
 //: concurrency/ExplicitCriticalSection.java
 // Using explicit Lock objects to create critical sections.
 package concurrency;
+
 import java.util.concurrent.locks.*;
 
 // Synchronize the entire method:
 class ExplicitPairManager1 extends PairManager {
     private Lock lock = new ReentrantLock();
+
+    @Override
     public synchronized void increment() {
         lock.lock();
         try {
@@ -21,6 +24,8 @@ class ExplicitPairManager1 extends PairManager {
 // Use a critical section:
 class ExplicitPairManager2 extends PairManager {
     private Lock lock = new ReentrantLock();
+
+    @Override
     public void increment() {
         Pair temp;
         lock.lock();

src/concurrency/FastSimulation.java

@@ -1,7 +1,9 @@
 package concurrency;//: concurrency/FastSimulation.java
+
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.*;
 import java.util.*;
+
 import static net.mindview.util.Print.*;
 
 public class FastSimulation {
@@ -11,18 +13,20 @@ public class FastSimulation {
     static final AtomicInteger[][] GRID =
             new AtomicInteger[N_ELEMENTS][N_GENES];
     static Random rand = new Random(47);
+
     static class Evolver implements Runnable {
+        @Override
         public void run() {
-      while(!Thread.interrupted()) {
+            while (!Thread.interrupted()) {
                 // Randomly select an element to work on:
                 int element = rand.nextInt(N_ELEMENTS);
-        for(int i = 0; i < N_GENES; i++) {
+                for (int i = 0; i < N_GENES; i++) {
                     int previous = element - 1;
-          if(previous < 0) {
+                    if (previous < 0) {
                         previous = N_ELEMENTS - 1;
                     }
                     int next = element + 1;
-          if(next >= N_ELEMENTS) {
+                    if (next >= N_ELEMENTS) {
                         next = 0;
                     }
                     int oldvalue = GRID[element][i].get();
@@ -30,7 +34,7 @@ public class FastSimulation {
                     int newvalue = oldvalue +
                             GRID[previous][i].get() + GRID[next][i].get();
                     newvalue /= 3; // Average the three values
-          if(!GRID[element][i]
+                    if (!GRID[element][i]
                             .compareAndSet(oldvalue, newvalue)) {
                         // Policy here to deal with failure. Here, we
                         // just report it and ignore it; our model
@@ -41,14 +45,15 @@ public class FastSimulation {
             }
         }
     }
+
     public static void main(String[] args) throws Exception {
         ExecutorService exec = Executors.newCachedThreadPool();
-    for(int i = 0; i < N_ELEMENTS; i++) {
+        for (int i = 0; i < N_ELEMENTS; i++) {
-        for(int j = 0; j < N_GENES; j++) {
+            for (int j = 0; j < N_GENES; j++) {
                 GRID[i][j] = new AtomicInteger(rand.nextInt(1000));
             }
         }
-    for(int i = 0; i < N_EVOLVERS; i++) {
+        for (int i = 0; i < N_EVOLVERS; i++) {
             exec.execute(new Evolver());
         }
         TimeUnit.SECONDS.sleep(5);

src/concurrency/Fat.java

@@ -5,12 +5,20 @@ public class Fat {
     private volatile double d; // Prevent optimization
     private static int counter = 0;
     private final int id = counter++;
+
     public Fat() {
         // Expensive, interruptible operation:
-    for(int i = 1; i < 10000; i++) {
+        for (int i = 1; i < 10000; i++) {
-      d += (Math.PI + Math.E) / (double)i;
+            d += (Math.PI + Math.E) / (double) i;
         }
     }
-  public void operation() { System.out.println(this); }
+
-  public String toString() { return "Fat id: " + id; }
+    public void operation() {
+        System.out.println(this);
+    }
+
+    @Override
+    public String toString() {
+        return "Fat id: " + id;
+    }
 } ///:~

src/concurrency/FixedDiningPhilosophers.java

@@ -1,25 +1,26 @@
 package concurrency;//: concurrency/FixedDiningPhilosophers.java
 // Dining philosophers without deadlock.
 // {Args: 5 5 timeout}
+
 import java.util.concurrent.*;
 
 public class FixedDiningPhilosophers {
     public static void main(String[] args) throws Exception {
         int ponder = 5;
-    if(args.length > 0) {
+        if (args.length > 0) {
             ponder = Integer.parseInt(args[0]);
         }
         int size = 5;
-    if(args.length > 1) {
+        if (args.length > 1) {
             size = Integer.parseInt(args[1]);
         }
         ExecutorService exec = Executors.newCachedThreadPool();
         Chopstick[] sticks = new Chopstick[size];
-    for(int i = 0; i < size; i++) {
+        for (int i = 0; i < size; i++) {
             sticks[i] = new Chopstick();
         }
-    for(int i = 0; i < size; i++) {
+        for (int i = 0; i < size; i++) {
-        if(i < (size-1)) {
+            if (i < (size - 1)) {
                 exec.execute(new Philosopher(
                         sticks[i], sticks[i + 1], i, ponder));
             } else {
@@ -27,7 +28,7 @@ public class FixedDiningPhilosophers {
                         sticks[0], sticks[i], i, ponder));
             }
         }
-    if(args.length == 3 && args[2].equals("timeout")) {
+        if (args.length == 3 && args[2].equals("timeout")) {
             TimeUnit.SECONDS.sleep(5);
         } else {
             System.out.println("Press 'Enter' to quit");

src/concurrency/FixedThreadPool.java

@@ -1,11 +1,12 @@
 package concurrency;//: concurrency/FixedThreadPool.java
+
 import java.util.concurrent.*;
 
 public class FixedThreadPool {
     public static void main(String[] args) {
         // Constructor argument is number of threads:
         ExecutorService exec = Executors.newFixedThreadPool(5);
-    for(int i = 0; i < 5; i++) {
+        for (int i = 0; i < 5; i++) {
             exec.execute(new LiftOff());
         }
         exec.shutdown();

src/concurrency/GreenhouseScheduler.java

@@ -2,6 +2,7 @@ package concurrency;//: concurrency/GreenhouseScheduler.java
 // Rewriting innerclasses/GreenhouseController.java
 // to use a ScheduledThreadPoolExecutor.
 // {Args: 5000}
+
 import java.util.concurrent.*;
 import java.util.*;
 
@@ -9,23 +10,30 @@ public class GreenhouseScheduler {
     private volatile boolean light = false;
     private volatile boolean water = false;
     private String thermostat = "Day";
+
     public synchronized String getThermostat() {
         return thermostat;
     }
+
     public synchronized void setThermostat(String value) {
         thermostat = value;
     }
+
     ScheduledThreadPoolExecutor scheduler =
             new ScheduledThreadPoolExecutor(10);
+
     public void schedule(Runnable event, long delay) {
-    scheduler.schedule(event,delay,TimeUnit.MILLISECONDS);
+        scheduler.schedule(event, delay, TimeUnit.MILLISECONDS);
     }
+
     public void
     repeat(Runnable event, long initialDelay, long period) {
         scheduler.scheduleAtFixedRate(
                 event, initialDelay, period, TimeUnit.MILLISECONDS);
     }
+
     class LightOn implements Runnable {
+        @Override
         public void run() {
             // Put hardware control code here to
             // physically turn on the light.
@@ -33,7 +41,9 @@ public class GreenhouseScheduler {
             light = true;
         }
     }
+
     class LightOff implements Runnable {
+        @Override
         public void run() {
             // Put hardware control code here to
             // physically turn off the light.
@@ -41,62 +51,81 @@ public class GreenhouseScheduler {
             light = false;
         }
     }
+
     class WaterOn implements Runnable {
+        @Override
         public void run() {
             // Put hardware control code here.
             System.out.println("Turning greenhouse water on");
             water = true;
         }
     }
+
     class WaterOff implements Runnable {
+        @Override
         public void run() {
             // Put hardware control code here.
             System.out.println("Turning greenhouse water off");
             water = false;
         }
     }
+
     class ThermostatNight implements Runnable {
+        @Override
         public void run() {
             // Put hardware control code here.
             System.out.println("Thermostat to night setting");
             setThermostat("Night");
         }
     }
+
     class ThermostatDay implements Runnable {
+        @Override
         public void run() {
             // Put hardware control code here.
             System.out.println("Thermostat to day setting");
             setThermostat("Day");
         }
     }
+
     class Bell implements Runnable {
-    public void run() { System.out.println("Bing!"); }
+        @Override
+        public void run() {
+            System.out.println("Bing!");
         }
+    }
+
     class Terminate implements Runnable {
+        @Override
         public void run() {
             System.out.println("Terminating");
             scheduler.shutdownNow();
             // Must start a separate task to do this job,
             // since the scheduler has been shut down:
             new Thread() {
+                @Override
                 public void run() {
-          for(DataPoint d : data) {
+                    for (DataPoint d : data) {
                         System.out.println(d);
                     }
                 }
             }.start();
         }
     }
+
     // New feature: data collection
     static class DataPoint {
         final Calendar time;
         final float temperature;
         final float humidity;
+
         public DataPoint(Calendar d, float temp, float hum) {
             time = d;
             temperature = temp;
             humidity = hum;
         }
+
+        @Override
         public String toString() {
             return time.getTime() +
                     String.format(
@@ -104,11 +133,14 @@ public class GreenhouseScheduler {
                             temperature, humidity);
         }
     }
+
     private Calendar lastTime = Calendar.getInstance();
+
     { // Adjust date to the half hour
         lastTime.set(Calendar.MINUTE, 30);
         lastTime.set(Calendar.SECOND, 00);
     }
+
     private float lastTemp = 65.0f;
     private int tempDirection = +1;
     private float lastHumidity = 50.0f;
@@ -116,21 +148,23 @@ public class GreenhouseScheduler {
     private Random rand = new Random(47);
     List<DataPoint> data = Collections.synchronizedList(
             new ArrayList<DataPoint>());
+
     class CollectData implements Runnable {
+        @Override
         public void run() {
             System.out.println("Collecting data");
-      synchronized(GreenhouseScheduler.this) {
+            synchronized (GreenhouseScheduler.this) {
                 // Pretend the interval is longer than it is:
                 lastTime.set(Calendar.MINUTE,
                         lastTime.get(Calendar.MINUTE) + 30);
                 // One in 5 chances of reversing the direction:
-        if(rand.nextInt(5) == 4) {
+                if (rand.nextInt(5) == 4) {
                     tempDirection = -tempDirection;
                 }
                 // Store previous value:
                 lastTemp = lastTemp +
                         tempDirection * (1.0f + rand.nextFloat());
-        if(rand.nextInt(5) == 4) {
+                if (rand.nextInt(5) == 4) {
                     humidityDirection = -humidityDirection;
                 }
                 lastHumidity = lastHumidity +
@@ -138,11 +172,12 @@ public class GreenhouseScheduler {
                 // Calendar must be cloned, otherwise all
                 // DataPoints hold references to the same lastTime.
                 // For a basic object like Calendar, clone() is OK.
-        data.add(new DataPoint((Calendar)lastTime.clone(),
+                data.add(new DataPoint((Calendar) lastTime.clone(),
                         lastTemp, lastHumidity));
             }
         }
     }
+
     public static void main(String[] args) {
         GreenhouseScheduler gh = new GreenhouseScheduler();
         gh.schedule(gh.new Terminate(), 5000);