gaspersic/java-design-patterns
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Java 11 migrate all remaining s (#1120)

Browse Source 
* 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
This commit is contained in:
Anurag Agarwal
2020-01-04 22:06:08 +05:30
committed by Ilkka Seppälä
parent 310ae50248
commit cd2a2e7711
98 changed files with 718 additions and 855 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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");
}

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

@ -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

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

@ -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);
}

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

@ -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);

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

@ -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);