Refactor Algorithms module

algorithms/src/main/java/com/baeldung/algorithms/dijkstra/Dijkstra.java

@@ -1,6 +1,5 @@
 package com.baeldung.algorithms.dijkstra;
 
-
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.Map.Entry;
@@ -12,15 +11,16 @@ public class Dijkstra {
 
         source.setDistance(0);
 
-        Set<Node> settledNodes = new HashSet<Node>();
-        Set<Node> unsettledNodes = new HashSet<Node>();
+        Set<Node> settledNodes = new HashSet<>();
+        Set<Node> unsettledNodes = new HashSet<>();
         unsettledNodes.add(source);
 
         while (unsettledNodes.size() != 0) {
             Node currentNode = getLowestDistanceNode(unsettledNodes);
             unsettledNodes.remove(currentNode);
-            for (Entry<Node, Integer> adjacencyPair : currentNode.getAdjacentNodes().entrySet())
-            {
+            for (Entry<Node, Integer> adjacencyPair : currentNode
+              .getAdjacentNodes()
+              .entrySet()) {
                 Node adjacentNode = adjacencyPair.getKey();
                 Integer edgeWeigh = adjacencyPair.getValue();
 
@@ -38,7 +38,7 @@ public class Dijkstra {
         Integer sourceDistance = sourceNode.getDistance();
         if (sourceDistance + edgeWeigh < evaluationNode.getDistance()) {
             evaluationNode.setDistance(sourceDistance + edgeWeigh);
-            LinkedList<Node> shortestPath = new LinkedList<Node>(sourceNode.getShortestPath());
+            LinkedList<Node> shortestPath = new LinkedList<>(sourceNode.getShortestPath());
             shortestPath.add(sourceNode);
             evaluationNode.setShortestPath(shortestPath);
         }

algorithms/src/main/java/com/baeldung/algorithms/dijkstra/Graph.java

@@ -5,7 +5,7 @@ import java.util.Set;
 
 public class Graph {
 
-    private Set<Node> nodes = new HashSet<Node>();
+    private Set<Node> nodes = new HashSet<>();
 
     public void addNode(Node nodeA) {
         nodes.add(nodeA);

algorithms/src/main/java/com/baeldung/algorithms/dijkstra/Main.java

@@ -1,9 +0,0 @@
-package com.baeldung.algorithms.dijkstra;
-
-public class Main {
-
-    public static void main(String[] args) {
-        
-        
-    }
-}

algorithms/src/main/java/com/baeldung/algorithms/dijkstra/Node.java

@@ -9,11 +9,11 @@ public class Node {
 
     private String name;
 
-    private LinkedList<Node> shortestPath = new LinkedList<Node>();
+    private LinkedList<Node> shortestPath = new LinkedList<>();
 
     private Integer distance = Integer.MAX_VALUE;
 
-    Map<Node, Integer> adjacentNodes = new HashMap<Node, Integer>();
+    private Map<Node, Integer> adjacentNodes = new HashMap<>();
 
     public Node(String name) {
         this.name = name;

algorithms/src/test/java/algorithms/DijkstraAlgorithmTest.java

@@ -1,15 +1,14 @@
 package algorithms;
 
-import static org.junit.Assert.*;
-
-import java.util.Arrays;
-import java.util.List;
-
-import org.junit.Test;
-
 import com.baeldung.algorithms.dijkstra.Dijkstra;
 import com.baeldung.algorithms.dijkstra.Graph;
 import com.baeldung.algorithms.dijkstra.Node;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
 
 public class DijkstraAlgorithmTest {
 
@@ -36,7 +35,7 @@ public class DijkstraAlgorithmTest {
 
         nodeF.addDestination(nodeE, 5);
 
-       Graph graph = new Graph();
+        Graph graph = new Graph();
 
         graph.addNode(nodeA);
         graph.addNode(nodeB);
@@ -53,22 +52,32 @@ public class DijkstraAlgorithmTest {
         List<Node> shortestPathForNodeE = Arrays.asList(nodeA, nodeB, nodeD);
         List<Node> shortestPathForNodeF = Arrays.asList(nodeA, nodeB, nodeD);
 
-        for(Node node : graph.getNodes()) {
+        for (Node node : graph.getNodes()) {
             switch (node.getName()) {
             case "B":
-                assertTrue(node.getShortestPath().equals(shortestPathForNodeB));
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeB));
                 break;
             case "C":
-                assertTrue(node.getShortestPath().equals(shortestPathForNodeC));
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeC));
                 break;
             case "D":
-                assertTrue(node.getShortestPath().equals(shortestPathForNodeD));
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeD));
                 break;
             case "E":
-                assertTrue(node.getShortestPath().equals(shortestPathForNodeE));
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeE));
                 break;
             case "F":
-                assertTrue(node.getShortestPath().equals(shortestPathForNodeF));
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeF));
                 break;
             }
         }

pom.xml

@@ -15,6 +15,7 @@
     </properties>
 
     <modules>
+        <module>algorithms</module>
         <module>annotations</module>
         <module>apache-cxf</module>
         <module>apache-fop</module>