Java 11 migrate all remaining s (#1120)

* Moves saga to Java 11

* Moves semaphore to Java 11

* Moves servant to Java 11

* Moves serverless to Java 11

* Moves service-layer to Java 11

* Moves service-locator to Java 11

* Moves sharding to Java 11

* Moves singleton to Java 11

* Moves spatial-partition to Java 11

* Moves specification to Java 11

* Moves state to Java 11

* Moves step-builder to Java 11

* Moves strategy to Java 11

* Moves subclass-sandbox to Java 11

* Fixes checkstyle issues

spatial-partition/README.md

@@ -19,9 +19,9 @@ Say, you are building a war game with hundreds, or maybe even thousands of playe
 
 ```java
 public void handleMeLee(Unit units[], int numUnits) {
-  for (int a = 0; a < numUnits - 1; a++)
+  for (var a = 0; a < numUnits - 1; a++)
   {
-    for (int b = a + 1; b < numUnits; b++)
+    for (var b = a + 1; b < numUnits; b++)
     {
       if (units[a].position() == units[b].position())
       {

spatial-partition/src/main/java/com/iluwatar/spatialpartition/App.java

@@ -23,8 +23,6 @@
 
 package com.iluwatar.spatialpartition;
 
-import java.util.ArrayList;
-import java.util.Enumeration;
 import java.util.Hashtable;
 import java.util.Random;
 import org.slf4j.Logger;
@@ -62,58 +60,46 @@ import org.slf4j.LoggerFactory;
 public class App {
   private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
 
-  static void noSpatialPartition(int height, int width,
-                                 int numOfMovements, Hashtable<Integer, Bubble> bubbles) {
-    ArrayList<Point> bubblesToCheck = new ArrayList<Point>();
-    for (Enumeration<Integer> e = bubbles.keys(); e.hasMoreElements(); ) {
-      bubblesToCheck.add(bubbles
-          .get(e.nextElement())); //all bubbles have to be checked for collision for all bubbles
-    }
+  static void noSpatialPartition(int numOfMovements, Hashtable<Integer, Bubble> bubbles) {
+    //all bubbles have to be checked for collision for all bubbles
+    var bubblesToCheck = bubbles.values();
 
     //will run numOfMovement times or till all bubbles have popped
     while (numOfMovements > 0 && !bubbles.isEmpty()) {
-      for (Enumeration<Integer> e = bubbles.keys(); e.hasMoreElements(); ) {
-        Integer i = e.nextElement();
+      bubbles.forEach((i, bubble) -> {
         // bubble moves, new position gets updated
         // and collisions are checked with all bubbles in bubblesToCheck
-        bubbles.get(i).move();
-        bubbles.replace(i, bubbles.get(i));
-        bubbles.get(i).handleCollision(bubblesToCheck, bubbles);
-      }
+        bubble.move();
+        bubbles.replace(i, bubble);
+        bubble.handleCollision(bubblesToCheck, bubbles);
+      });
       numOfMovements--;
     }
-    for (Integer key : bubbles.keySet()) {
-      //bubbles not popped
-      LOGGER.info("Bubble " + key + " not popped");
-    }
+    //bubbles not popped
+    bubbles.keySet().stream().map(key -> "Bubble " + key + " not popped").forEach(LOGGER::info);
   }
 
   static void withSpatialPartition(
       int height, int width, int numOfMovements, Hashtable<Integer, Bubble> bubbles) {
     //creating quadtree
-    Rect rect = new Rect(width / 2, height / 2, width, height);
-    QuadTree quadTree = new QuadTree(rect, 4);
+    var rect = new Rect(width / 2, height / 2, width, height);
+    var quadTree = new QuadTree(rect, 4);
 
     //will run numOfMovement times or till all bubbles have popped
     while (numOfMovements > 0 && !bubbles.isEmpty()) {
       //quadtree updated each time
-      for (Enumeration<Integer> e = bubbles.keys(); e.hasMoreElements(); ) {
-        quadTree.insert(bubbles.get(e.nextElement()));
-      }
-      for (Enumeration<Integer> e = bubbles.keys(); e.hasMoreElements(); ) {
-        Integer i = e.nextElement();
+      bubbles.values().forEach(quadTree::insert);
+      bubbles.forEach((i, bubble) -> {
         //bubble moves, new position gets updated, quadtree used to reduce computations
-        bubbles.get(i).move();
-        bubbles.replace(i, bubbles.get(i));
-        SpatialPartitionBubbles sp = new SpatialPartitionBubbles(bubbles, quadTree);
-        sp.handleCollisionsUsingQt(bubbles.get(i));
-      }
+        bubble.move();
+        bubbles.replace(i, bubble);
+        var sp = new SpatialPartitionBubbles(bubbles, quadTree);
+        sp.handleCollisionsUsingQt(bubble);
+      });
       numOfMovements--;
     }
-    for (Integer key : bubbles.keySet()) {
-      //bubbles not popped
-      LOGGER.info("Bubble " + key + " not popped");
-    }
+    //bubbles not popped
+    bubbles.keySet().stream().map(key -> "Bubble " + key + " not popped").forEach(LOGGER::info);
   }
 
   /**
@@ -123,23 +109,23 @@ public class App {
    */
 
   public static void main(String[] args) {
-    Hashtable<Integer, Bubble> bubbles1 = new Hashtable<Integer, Bubble>();
-    Hashtable<Integer, Bubble> bubbles2 = new Hashtable<Integer, Bubble>();
-    Random rand = new Random();
+    var bubbles1 = new Hashtable<Integer, Bubble>();
+    var bubbles2 = new Hashtable<Integer, Bubble>();
+    var rand = new Random();
     for (int i = 0; i < 10000; i++) {
-      Bubble b = new Bubble(rand.nextInt(300), rand.nextInt(300), i, rand.nextInt(2) + 1);
+      var b = new Bubble(rand.nextInt(300), rand.nextInt(300), i, rand.nextInt(2) + 1);
       bubbles1.put(i, b);
       bubbles2.put(i, b);
       LOGGER.info("Bubble " + i + " with radius " + b.radius
           + " added at (" + b.coordinateX + "," + b.coordinateY + ")");
     }
 
-    long start1 = System.currentTimeMillis();
-    App.noSpatialPartition(300, 300, 20, bubbles1);
-    long end1 = System.currentTimeMillis();
-    long start2 = System.currentTimeMillis();
+    var start1 = System.currentTimeMillis();
+    App.noSpatialPartition(20, bubbles1);
+    var end1 = System.currentTimeMillis();
+    var start2 = System.currentTimeMillis();
     App.withSpatialPartition(300, 300, 20, bubbles2);
-    long end2 = System.currentTimeMillis();
+    var end2 = System.currentTimeMillis();
     LOGGER.info("Without spatial partition takes " + (end1 - start1) + "ms");
     LOGGER.info("With spatial partition takes " + (end2 - start2) + "ms");
   }

spatial-partition/src/main/java/com/iluwatar/spatialpartition/Bubble.java

@@ -23,7 +23,7 @@
 
 package com.iluwatar.spatialpartition;
 
-import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Hashtable;
 import java.util.Random;
 import org.slf4j.Logger;
@@ -64,10 +64,10 @@ public class Bubble extends Point<Bubble> {
     allBubbles.remove(this.id);
   }
 
-  void handleCollision(ArrayList<Point> bubblesToCheck, Hashtable<Integer, Bubble> allBubbles) {
-    boolean toBePopped = false; //if any other bubble collides with it, made true
-    for (int i = 0; i < bubblesToCheck.size(); i++) {
-      Integer otherId = bubblesToCheck.get(i).id;
+  void handleCollision(Collection<? extends Point> toCheck, Hashtable<Integer, Bubble> allBubbles) {
+    var toBePopped = false; //if any other bubble collides with it, made true
+    for (var point : toCheck) {
+      var otherId = point.id;
       if (allBubbles.get(otherId) != null && //the bubble hasn't been popped yet
           this.id != otherId && //the two bubbles are not the same
           this.touches(allBubbles.get(otherId))) { //the bubbles touch

spatial-partition/src/main/java/com/iluwatar/spatialpartition/Point.java

@@ -23,7 +23,7 @@
 
 package com.iluwatar.spatialpartition;
 
-import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Hashtable;
 
 /**
@@ -61,8 +61,8 @@ public abstract class Point<T> {
   /**
    * handling interactions/collisions with other objects.
    *
-   * @param pointsToCheck contains the objects which need to be checked
-   * @param allPoints     contains hashtable of all points on field at this time
+   * @param toCheck contains the objects which need to be checked
+   * @param all     contains hashtable of all points on field at this time
    */
-  abstract void handleCollision(ArrayList<Point> pointsToCheck, Hashtable<Integer, T> allPoints);
+  abstract void handleCollision(Collection<? extends Point> toCheck, Hashtable<Integer, T> all);
 }

spatial-partition/src/main/java/com/iluwatar/spatialpartition/QuadTree.java

@@ -23,8 +23,7 @@
 
 package com.iluwatar.spatialpartition;
 
-import java.util.ArrayList;
-import java.util.Enumeration;
+import java.util.Collection;
 import java.util.Hashtable;
 
 /**
@@ -47,7 +46,7 @@ public class QuadTree {
     this.boundary = boundary;
     this.capacity = capacity;
     this.divided = false;
-    this.points = new Hashtable<Integer, Point>();
+    this.points = new Hashtable<>();
     this.northwest = null;
     this.northeast = null;
     this.southwest = null;
@@ -76,30 +75,29 @@ public class QuadTree {
   }
 
   void divide() {
-    double x = this.boundary.coordinateX;
-    double y = this.boundary.coordinateY;
-    double width = this.boundary.width;
-    double height = this.boundary.height;
-    Rect nw = new Rect(x - width / 4, y + height / 4, width / 2, height / 2);
+    var x = this.boundary.coordinateX;
+    var y = this.boundary.coordinateY;
+    var width = this.boundary.width;
+    var height = this.boundary.height;
+    var nw = new Rect(x - width / 4, y + height / 4, width / 2, height / 2);
     this.northwest = new QuadTree(nw, this.capacity);
-    Rect ne = new Rect(x + width / 4, y + height / 4, width / 2, height / 2);
+    var ne = new Rect(x + width / 4, y + height / 4, width / 2, height / 2);
     this.northeast = new QuadTree(ne, this.capacity);
-    Rect sw = new Rect(x - width / 4, y - height / 4, width / 2, height / 2);
+    var sw = new Rect(x - width / 4, y - height / 4, width / 2, height / 2);
     this.southwest = new QuadTree(sw, this.capacity);
-    Rect se = new Rect(x + width / 4, y - height / 4, width / 2, height / 2);
+    var se = new Rect(x + width / 4, y - height / 4, width / 2, height / 2);
     this.southeast = new QuadTree(se, this.capacity);
     this.divided = true;
   }
 
-  ArrayList<Point> query(Rect r, ArrayList<Point> relevantPoints) {
+  Collection<Point> query(Rect r, Collection<Point> relevantPoints) {
     //could also be a circle instead of a rectangle
     if (this.boundary.intersects(r)) {
-      for (Enumeration<Integer> e = this.points.keys(); e.hasMoreElements(); ) {
-        Integer i = e.nextElement();
-        if (r.contains(this.points.get(i))) {
-          relevantPoints.add(this.points.get(i));
-        }
-      }
+      this.points
+          .values()
+          .stream()
+          .filter(r::contains)
+          .forEach(relevantPoints::add);
       if (this.divided) {
         this.northwest.query(r, relevantPoints);
         this.northeast.query(r, relevantPoints);

spatial-partition/src/main/java/com/iluwatar/spatialpartition/SpatialPartitionBubbles.java

@@ -24,6 +24,7 @@
 package com.iluwatar.spatialpartition;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Hashtable;
 
 /**
@@ -44,8 +45,8 @@ public class SpatialPartitionBubbles extends SpatialPartitionGeneric<Bubble> {
   void handleCollisionsUsingQt(Bubble b) {
     // finding points within area of a square drawn with centre same as
     // centre of bubble and length = radius of bubble
-    Rect rect = new Rect(b.coordinateX, b.coordinateY, 2 * b.radius, 2 * b.radius);
-    ArrayList<Point> quadTreeQueryResult = new ArrayList<Point>();
+    var rect = new Rect(b.coordinateX, b.coordinateY, 2 * b.radius, 2 * b.radius);
+    var quadTreeQueryResult = new ArrayList<Point>();
     this.quadTree.query(rect, quadTreeQueryResult);
     //handling these collisions
     b.handleCollision(quadTreeQueryResult, this.bubbles);

spatial-partition/src/test/java/com/iluwatar/spatialpartition/BubbleTest.java

@@ -23,62 +23,71 @@
 
 package com.iluwatar.spatialpartition;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import java.util.ArrayList;
 import java.util.Hashtable;
 import org.junit.jupiter.api.Test;
 
 /**
-* Testing methods in Bubble class.
-*/
+ * Testing methods in Bubble class.
+ */
 
 class BubbleTest {
 
   @Test
   void moveTest() {
-    Bubble b = new Bubble(10,10,1,2);
-    int initialX = b.coordinateX;
-    int initialY = b.coordinateY;
+    var b = new Bubble(10, 10, 1, 2);
+    var initialX = b.coordinateX;
+    var initialY = b.coordinateY;
     b.move();
     //change in x and y < |2|
-    assertTrue((b.coordinateX - initialX < 2 && b.coordinateX - initialX > -2) && (b.coordinateY - initialY < 2 && b.coordinateY - initialY > -2));
+    assertTrue(b.coordinateX - initialX < 2 && b.coordinateX - initialX > -2);
+    assertTrue(b.coordinateY - initialY < 2 && b.coordinateY - initialY > -2);
   }
 
   @Test
   void touchesTest() {
-    Bubble b1 = new Bubble(0,0,1,2);
-    Bubble b2 = new Bubble(1,1,2,1);
-    Bubble b3 = new Bubble(10,10,3,1);
+    var b1 = new Bubble(0, 0, 1, 2);
+    var b2 = new Bubble(1, 1, 2, 1);
+    var b3 = new Bubble(10, 10, 3, 1);
     //b1 touches b2 but not b3
-    assertTrue(b1.touches(b2) && !b1.touches(b3));
+    assertTrue(b1.touches(b2));
+    assertFalse(b1.touches(b3));
   }
 
   @Test
   void popTest() {
-    Bubble b1 = new Bubble(10,10,1,2);
-    Bubble b2 = new Bubble(0,0,2,2);
-    Hashtable<Integer, Bubble> bubbles = new Hashtable<Integer, Bubble>();
-    bubbles.put(1, b1); 
+    var b1 = new Bubble(10, 10, 1, 2);
+    var b2 = new Bubble(0, 0, 2, 2);
+    var bubbles = new Hashtable<Integer, Bubble>();
+    bubbles.put(1, b1);
     bubbles.put(2, b2);
     b1.pop(bubbles);
     //after popping, bubble no longer in hashtable containing all bubbles
-    assertTrue(bubbles.get(1) == null && bubbles.get(2) != null);
+    assertNull(bubbles.get(1));
+    assertNotNull(bubbles.get(2));
   }
 
   @Test
   void handleCollisionTest() {
-    Bubble b1 = new Bubble(0,0,1,2);
-    Bubble b2 = new Bubble(1,1,2,1);
-    Bubble b3 = new Bubble(10,10,3,1);
-    Hashtable<Integer, Bubble> bubbles = new Hashtable<Integer, Bubble>();
-    bubbles.put(1, b1); 
-    bubbles.put(2, b2); 
+    var b1 = new Bubble(0, 0, 1, 2);
+    var b2 = new Bubble(1, 1, 2, 1);
+    var b3 = new Bubble(10, 10, 3, 1);
+    var bubbles = new Hashtable<Integer, Bubble>();
+    bubbles.put(1, b1);
+    bubbles.put(2, b2);
     bubbles.put(3, b3);
-    ArrayList<Point> bubblesToCheck = new ArrayList<Point>();
-    bubblesToCheck.add(b2); 
+    var bubblesToCheck = new ArrayList<Point>();
+    bubblesToCheck.add(b2);
     bubblesToCheck.add(b3);
     b1.handleCollision(bubblesToCheck, bubbles);
     //b1 touches b2 and not b3, so b1, b2 will be popped
-    assertTrue(bubbles.get(1) == null && bubbles.get(2) == null && bubbles.get(3) != null);
+    assertNull(bubbles.get(1));
+    assertNull(bubbles.get(2));
+    assertNotNull(bubbles.get(3));
   }
 }

spatial-partition/src/test/java/com/iluwatar/spatialpartition/QuadTreeTest.java

@@ -23,12 +23,13 @@
 
 package com.iluwatar.spatialpartition;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Hashtable;
 import java.util.Random;
-
-
+import java.util.stream.Collectors;
 import org.junit.jupiter.api.Test;
 
 /**
@@ -39,41 +40,34 @@ class QuadTreeTest {
 
   @Test
   void queryTest() {
-    ArrayList<Point> points = new ArrayList<Point>();
-    Random rand = new Random();
+    var points = new ArrayList<Point>();
+    var rand = new Random();
     for (int i = 0; i < 20; i++) {
-      Bubble p = new Bubble(rand.nextInt(300), rand.nextInt(300), i, rand.nextInt(2) + 1);
+      var p = new Bubble(rand.nextInt(300), rand.nextInt(300), i, rand.nextInt(2) + 1);
       points.add(p);
     }
-    Rect field = new Rect(150,150,300,300); //size of field
-    Rect queryRange = new Rect(70,130,100,100); //result = all points lying in this rectangle
+    var field = new Rect(150, 150, 300, 300); //size of field
+    var queryRange = new Rect(70, 130, 100, 100); //result = all points lying in this rectangle
     //points found in the query range using quadtree and normal method is same
-    assertTrue(QuadTreeTest.quadTreeTest(points, field, queryRange).equals(QuadTreeTest.verify(points, queryRange)));
+    var points1 = QuadTreeTest.quadTreeTest(points, field, queryRange);
+    var points2 = QuadTreeTest.verify(points, queryRange);
+    assertEquals(points1, points2);
   }
 
-  static Hashtable<Integer, Point> quadTreeTest(ArrayList<Point> points, Rect field, Rect queryRange) {
+  static Hashtable<Integer, Point> quadTreeTest(Collection<Point> points, Rect field, Rect queryRange) {
     //creating quadtree and inserting all points
-    QuadTree qTree = new QuadTree(queryRange, 4);
-    for (int i = 0; i < points.size(); i++) {
-      qTree.insert(points.get(i));
-    }
+    var qTree = new QuadTree(queryRange, 4);
+    points.forEach(qTree::insert);
 
-    ArrayList<Point> queryResult = qTree.query(field, new ArrayList<Point>());
-    Hashtable<Integer, Point> result = new Hashtable<Integer, Point>();
-    for (int i = 0; i < queryResult.size(); i++) {
-      Point p = queryResult.get(i);
-      result.put(p.id, p);
-    }
-    return result;
+    return qTree
+        .query(field, new ArrayList<>())
+        .stream()
+        .collect(Collectors.toMap(p -> p.id, p -> p, (a, b) -> b, Hashtable::new));
   }
 
-  static Hashtable<Integer, Point> verify(ArrayList<Point> points, Rect queryRange) {
-    Hashtable<Integer, Point> result = new Hashtable<Integer, Point>();
-    for (int i = 0; i < points.size(); i++) {
-      if (queryRange.contains(points.get(i))) {
-        result.put(points.get(i).id, points.get(i));
-      }
-    }
-    return result;
+  static Hashtable<Integer, Point> verify(Collection<Point> points, Rect queryRange) {
+    return points.stream()
+        .filter(queryRange::contains)
+        .collect(Collectors.toMap(point -> point.id, point -> point, (a, b) -> b, Hashtable::new));
   }
 }

spatial-partition/src/test/java/com/iluwatar/spatialpartition/RectTest.java

@@ -23,7 +23,9 @@
 
 package com.iluwatar.spatialpartition;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
 import org.junit.jupiter.api.Test;
 
 /**
@@ -34,19 +36,21 @@ class RectTest {
 
   @Test
   void containsTest() {
-    Rect r = new Rect(10,10,20,20);
-    Bubble b1 = new Bubble(2,2,1,1);
-    Bubble b2 = new Bubble(30,30,2,1);
+    var r = new Rect(10, 10, 20, 20);
+    var b1 = new Bubble(2, 2, 1, 1);
+    var b2 = new Bubble(30, 30, 2, 1);
     //r contains b1 and not b2
-    assertTrue(r.contains(b1) && !r.contains(b2));
+    assertTrue(r.contains(b1));
+    assertFalse(r.contains(b2));
   }
 
   @Test
   void intersectsTest() {
-    Rect r1 = new Rect(10,10,20,20);
-    Rect r2 = new Rect(15,15,20,20);
-    Rect r3 = new Rect(50,50,20,20);
+    var r1 = new Rect(10, 10, 20, 20);
+    var r2 = new Rect(15, 15, 20, 20);
+    var r3 = new Rect(50, 50, 20, 20);
     //r1 intersects r2 and not r3
-    assertTrue(r1.intersects(r2) && !r1.intersects(r3));
+    assertTrue(r1.intersects(r2));
+    assertFalse(r1.intersects(r3));
   }
 }

spatial-partition/src/test/java/com/iluwatar/spatialpartition/SpatialPartitionBubblesTest.java

@@ -23,7 +23,9 @@
 
 package com.iluwatar.spatialpartition;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+
 import java.util.Hashtable;
 import org.junit.jupiter.api.Test;
 
@@ -35,24 +37,27 @@ class SpatialPartitionBubblesTest {
 
   @Test
   void handleCollisionsUsingQtTest() {
-    Bubble b1 = new Bubble(10,10,1,3);
-    Bubble b2 = new Bubble(5,5,2,1);
-    Bubble b3 = new Bubble(9,9,3,1);
-    Bubble b4 = new Bubble(8,8,4,2);
-    Hashtable<Integer, Bubble> bubbles = new Hashtable<Integer, Bubble>();
-    bubbles.put(1, b1); 
-    bubbles.put(2, b2); 
-    bubbles.put(3, b3); 
+    var b1 = new Bubble(10, 10, 1, 3);
+    var b2 = new Bubble(5, 5, 2, 1);
+    var b3 = new Bubble(9, 9, 3, 1);
+    var b4 = new Bubble(8, 8, 4, 2);
+    var bubbles = new Hashtable<Integer, Bubble>();
+    bubbles.put(1, b1);
+    bubbles.put(2, b2);
+    bubbles.put(3, b3);
     bubbles.put(4, b4);
-    Rect r = new Rect(10,10,20,20);
-    QuadTree qt = new QuadTree(r,4);
-    qt.insert(b1); 
-    qt.insert(b2); 
-    qt.insert(b3); 
+    var r = new Rect(10, 10, 20, 20);
+    var qt = new QuadTree(r, 4);
+    qt.insert(b1);
+    qt.insert(b2);
+    qt.insert(b3);
     qt.insert(b4);
-    SpatialPartitionBubbles sp = new SpatialPartitionBubbles(bubbles, qt);
+    var sp = new SpatialPartitionBubbles(bubbles, qt);
     sp.handleCollisionsUsingQt(b1);
     //b1 touches b3 and b4 but not b2 - so b1,b3,b4 get popped
-    assertTrue(bubbles.get(1) == null && bubbles.get(2) != null && bubbles.get(3) == null && bubbles.get(4) == null);
+    assertNull(bubbles.get(1));
+    assertNotNull(bubbles.get(2));
+    assertNull(bubbles.get(3));
+    assertNull(bubbles.get(4));
   }
 }