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,18 +11,19 @@ public class Dijkstra {
 
         source.setDistance(0);
 
-        Set<Node> settledNodes = new HashSet<Node>();
+        Set<Node> settledNodes = new HashSet<>();
-        Set<Node> unsettledNodes = new HashSet<Node>();
+        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();
-                
+
                 if (!settledNodes.contains(adjacentNode)) {
                     CalculateMinimumDistance(adjacentNode, edgeWeigh, currentNode);
                     unsettledNodes.add(adjacentNode);
@@ -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,8 +5,8 @@ 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

@@ -6,35 +6,35 @@ import java.util.List;
 import java.util.Map;
 
 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;
     }
-    
+
     public void addDestination(Node destination, int distance) {
         adjacentNodes.put(destination, distance);
     }
-    
+
     public String getName() {
         return name;
     }
-    
+
     public void setName(String name) {
         this.name = name;
     }
-    
+
     public Map<Node, Integer> getAdjacentNodes() {
         return adjacentNodes;
     }
-    
+
     public void setAdjacentNodes(Map<Node, Integer> adjacentNodes) {
         this.adjacentNodes = adjacentNodes;
     }

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

@@ -1,74 +1,83 @@
 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 {
 
     @Test
     public void whenSPPSolved_thenCorrect() {
-        
+
         Node nodeA = new Node("A");
         Node nodeB = new Node("B");
         Node nodeC = new Node("C");
-        Node nodeD = new Node("D"); 
+        Node nodeD = new Node("D");
         Node nodeE = new Node("E");
         Node nodeF = new Node("F");
-        
+
         nodeA.addDestination(nodeB, 10);
         nodeA.addDestination(nodeC, 15);
-        
+
         nodeB.addDestination(nodeD, 12);
         nodeB.addDestination(nodeF, 15);
-        
+
         nodeC.addDestination(nodeE, 10);
-        
+
         nodeD.addDestination(nodeE, 2);
         nodeD.addDestination(nodeF, 1);
-        
+
         nodeF.addDestination(nodeE, 5);
-        
+
-       Graph graph = new Graph();
+        Graph graph = new Graph();
-        
+
         graph.addNode(nodeA);
         graph.addNode(nodeB);
         graph.addNode(nodeC);
         graph.addNode(nodeD);
         graph.addNode(nodeE);
         graph.addNode(nodeF);
-        
+
         graph = Dijkstra.calculateShortestPathFromSource(graph, nodeA);
-        
+
         List<Node> shortestPathForNodeB = Arrays.asList(nodeA);
         List<Node> shortestPathForNodeC = Arrays.asList(nodeA);
         List<Node> shortestPathForNodeD = Arrays.asList(nodeA, nodeB);
         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>