Nodes are needed to show coordinates

src/Task9.java

+import java.io.BufferedReader;
+import java.io.FileReader;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -7,17 +9,28 @@ import java.util.*;
 public class Task9 {
   public static void main(String[] args) {
 
-    Graph g = new Graph("noder Iceland.txt");
-    g.loadEdges("kanterIceland.txt");
+    Graph g = null;
+    try {
+      g = new Graph("noder Iceland.txt");
+    } catch (IOException e) {
+      e.printStackTrace();
+    }
+    Objects.requireNonNull(g).loadEdges("kanterIceland.txt");
     int startNumber = 0;
-    List<Edge> edges = Dijkstra.getShortestPath(g,startNumber,3);
-    Node node = g.getNode(startNumber);
-    System.out.println(node.getLatitude() + "," +  node.getLongitude());
+    List<Edge> edges = g.getShortestPath(0,3);
+    for(Edge edge: edges){
+      System.out.println("From " + edge.start() + " to "+ edge.destination() + " in " + edge.drivingTime() + " s/100");
+    }
+    System.out.println("----------------------- Dijkstra Done --------------------------------");
+    g.loadNodes(Utils.generatePath("noder Iceland.txt"));
+    List<Node> nodes = g.getNodes();
+    System.out.println(nodes.get(startNumber).getLatitude()+","+nodes.get(startNumber).getLongitude());
     for(Edge edge : edges){
-      node = g.getNode(edge.destination());
-      System.out.println(node.getLatitude() + "," +  node.getLongitude());
+      Node destination = nodes.get(edge.destination());
+      System.out.println(destination.getLatitude() +","+destination.getLongitude());
     }
   }
+
 }
 class Node{
   private final int number;
@@ -25,7 +38,6 @@ class Node{
   private final double longitude;
   private String[] typeArray;
   private String name;
-  //private final List<Edge> edges = new ArrayList<>();
 
   public Node(int number, double latitude, double longitude) {
     this.number = number;
@@ -73,10 +85,6 @@ class Node{
     }
   }
 
-  /*public void addEdge(int destination, int drivingTime, int distance, int speedLimit){
-    edges.add(new Edge(this.getNumber(),destination,drivingTime,distance,speedLimit));
-  }*/
-
   public boolean isTypeOf(String typeName){
     return Arrays.stream(typeArray).anyMatch(t -> t.equalsIgnoreCase(typeName));
   }
@@ -107,18 +115,21 @@ record Edge(int start, int destination, int drivingTime) implements Comparable<E
 }
 
 class Graph{
-  private final List<Node> nodes;
   private final HashMap<Integer, List<Edge>> adjacencyList = new HashMap<>();
+  private List<Node> nodes = new ArrayList<>();
 
-  public Graph(String inFile) {
-    nodes = loadNodes(inFile);
-    for(int i = 0; i < nodes.size(); ++i) {
+  public List<Node> getNodes() {
+    return nodes;
+  }
+
+  public Graph(String inFile) throws IOException {
+    int numberOfNodes = Utils.readFirstLine(inFile);
+    for(int i = 0; i < numberOfNodes; ++i) {
       adjacencyList.put(i, new ArrayList<>());
     }
   }
 
   public List<Node> loadNodes(String inFile) {
-    List<Node> nodes = new ArrayList<>();
     List<String> data = Utils.readFile(inFile);
     for(int i = 1; i < data.size(); ++i) {
       String[] splitText = Utils.dividedText(data.get(i), 3);
@@ -141,55 +152,10 @@ class Graph{
     adjacencyList.get(start).add(new Edge(start,destination, drivingTime));
   }
 
-  public Node getNode(int nodeNumber){
-    return nodes.get(nodeNumber);
-  }
-
-  public List<Edge> getAllEdgesFromNode(int nodeNumber){
-    return adjacencyList.get(nodeNumber);
-  }
-  /*public void readNodeInformation(List<String> data){
-    for(String text : data){
-      if(!text.equals(data.get(0))){
-        String [] splitText = Utils.dividedText(text,3);
-        this.setTypes(Integer.parseInt(splitText[0]),Integer.parseInt(splitText[1]),splitText[2]);
-      }
-    }
-  }*/
-
-  /*private void setTypes(int nodeNumber,int typeValue, String name){
-    Node node = this.getNode(nodeNumber);
-
-    if((typeValue&1) ==1) node.setType("Place name");
-    if((typeValue&2) == 2) node.setType("Gas station");
-    if((typeValue&4) == 4) node.setType("Charge station");
-    if((typeValue&8) == 8) node.setType("Eating place");
-    if((typeValue&16) == 16) node.setType("Drinking place");
-    if((typeValue&32) == 32) node.setType("Accommodation");
-
-    node.setName(name);
-  }*/
-
-  public int getNumberOfNodes(){
-    return nodes.size();
-  }
-
-
-  public int getNumberOfNodeByName(String name){
-    for(Node node: nodes){
-      if(node.getName() != null){
-        if(node.getName().equalsIgnoreCase(name)) {
-          return node.getNumber();
-        }
-      }
-    }
-    return -1;
-  }
-
   public List<Edge> getShortestPath(int startNumber, int destinationNumber){
     PriorityQueue<Edge> priorityQueue = new PriorityQueue<>();
-    int nodeSize = nodes.size();
-    int[] pathWeight = new int[nodes.size()];
+    int nodeSize = adjacencyList.size();
+    int[] pathWeight = new int[adjacencyList.size()];
     Arrays.fill(pathWeight, Integer.MAX_VALUE);
     List<Edge>[] pathToNodes = new List[nodeSize];
     pathWeight[startNumber] = 0;
@@ -212,92 +178,6 @@ class Graph{
 
 }
 
-
-class Dijkstra{
-  public static List<Edge> getShortestPath(Graph graph, int startNumber, int destinationNumber){
-    PriorityQueue<Edge> priorityQueue = new PriorityQueue<>();
-    int[] pathWeight = new int[graph.getNumberOfNodes()];
-    Arrays.fill(pathWeight, Integer.MAX_VALUE);
-    List<Edge>[] pathToNodes = new List[graph.getNumberOfNodes()];
-    pathWeight[startNumber] = 0;
-    Arrays.fill(pathToNodes,new ArrayList<>());
-    priorityQueue.addAll(graph.getAllEdgesFromNode(startNumber));
-    while (!priorityQueue.isEmpty()){
-      Edge nextEdge = priorityQueue.poll();
-      int nextNode = nextEdge.destination();
-      int currentSum = pathWeight[nextEdge.start()] + nextEdge.drivingTime();
-      if(currentSum<pathWeight[nextNode]){
-        pathWeight[nextNode] = currentSum;
-        pathToNodes[nextNode] = new ArrayList<>(pathToNodes[nextEdge.start()]);
-        pathToNodes[nextNode].add(nextEdge);
-        priorityQueue.addAll(graph.getAllEdgesFromNode(nextNode));
-      }
-    }
-    return pathToNodes[destinationNumber];
-  }
-  /*public static List<Edge> getShortestPath(Graph graph, int startNumber, int destinationNumber){
-    PriorityQueue<Edge> priorityQueue = new PriorityQueue<>();
-    Node startNode = graph.getNode(startNumber);
-    //boolean[] visitedNodes = new boolean[graph.getNumberOfNodes()];
-    int[] pathWeight = new int[graph.getNumberOfNodes()];
-    Arrays.fill(pathWeight, Integer.MAX_VALUE);
-    List<Edge>[] pathToNodes = new List[graph.getNumberOfNodes()];
-    //visitedNodes[startNumber] = true;
-    pathWeight[startNumber] = 0;
-    Arrays.fill(pathToNodes,new ArrayList<>());
-    priorityQueue.addAll(startNode.getEdges());
-    System.out.println("Debugging");
-    while (!priorityQueue.isEmpty()){
-      Edge nextEdge = priorityQueue.poll();
-      int nextNode = nextEdge.destination();
-      int currentSum = pathWeight[nextEdge.start()] + nextEdge.drivingTime();
-      if(currentSum < pathWeight[nextNode]){
-        pathWeight[nextNode] = currentSum;
-        pathToNodes[nextNode] = new ArrayList<>(pathToNodes[nextEdge.start()]);
-        //pathToNodes[nextNode.getNumber()].addAll(pathToNodes[nextEdge.getStart().getNumber()]);
-        pathToNodes[nextNode].add(nextEdge);
-        priorityQueue.addAll( graph.getNode(nextNode).getEdges());
-      }
-    }
-    return pathToNodes[destinationNumber];
-  }*/
-/*
-  public static ListOfPlaces getClosePlaces(Graph graph, int startNumber, String typOfPlace, int numberOfPlaces){
-    ListOfPlaces listOfPlaces = new ListOfPlaces(numberOfPlaces);
-    PriorityQueue<Edge> priorityQueue = new PriorityQueue<>();
-    Node startNode = graph.getNode(startNumber);
-    //boolean[] visitedNodes = new boolean[graph.getNumberOfNodes()];
-    int[] pathWeight = new int[graph.getNumberOfNodes()];
-    Arrays.fill(pathWeight, Integer.MAX_VALUE);
-    List<Edge>[] pathToNodes = new List[graph.getNumberOfNodes()];
-    //visitedNodes[startNumber] = true;
-    pathWeight[startNumber] = 0;
-    Arrays.fill(pathToNodes,new ArrayList<>());
-    priorityQueue.addAll(startNode.getEdges());
-    System.out.println("Debugging");
-    while (!priorityQueue.isEmpty()){
-      Edge nextEdge = priorityQueue.poll();
-      System.out.println(nextEdge.getStart()+ " -------> " + nextEdge.getDestination() + "  Time: " + nextEdge.getDrivingTime());
-      Node nextNode = nextEdge.getDestination();
-      int currentSum = pathWeight[nextEdge.getStart().getNumber()] + nextEdge.getDrivingTime();
-      if(currentSum < pathWeight[nextNode.getNumber()]){
-        pathWeight[nextNode.getNumber()] = currentSum;
-        pathToNodes[nextNode.getNumber()] = new ArrayList<>(pathToNodes[nextEdge.getStart().getNumber()]);
-        //pathToNodes[nextNode.getNumber()].addAll(pathToNodes[nextEdge.getStart().getNumber()]);
-        pathToNodes[nextNode.getNumber()].add(nextEdge);
-        priorityQueue.addAll(nextNode.getEdges());
-        if (nextNode.getName() != null){
-          if(nextNode.isTypeOf(typOfPlace)){
-            listOfPlaces.addPlace(nextNode,currentSum);
-          }
-        }
-      }
-    }
-    return listOfPlaces;
-  }
-*/
-}
-
 class ListOfPlaces{
   private final Map<Node, Integer> placeList = new HashMap<>();
   int maxDriveTime = 0;
@@ -402,4 +282,10 @@ class Utils{
     }
     return divided;
   }
+
+  public static int readFirstLine(String nameFile) throws IOException {
+    BufferedReader brTest = new BufferedReader(new FileReader(Utils.generatePath(nameFile)));
+    return Integer.parseInt(brTest.readLine().trim());
+  }
+
 }

src/Trying.java

-import java.util.*;
-
-public class Trying {
-  public static void main(String[] args) {
-    NewGraph graph = new NewGraph();
-    System.out.println("Reading Nodes");
-    graph.readAllNodes(Utils.readFile(Utils.generatePath("noder.txt")));
-    System.out.println("Reading edges");
-    graph.readAllEdges(Utils.readFile(Utils.generatePath("kanter.txt")));
-    System.out.println("Finished");
-  }
-}
-
-class NewNode {
-  private final int number;
-  private final double latitude;
-  private final double longitude;
-  private String[] typeArray;
-  private String name;
-  public NewNode(int number, double latitude, double longitude) {
-    this.number = number;
-    this.latitude = latitude;
-    this.longitude = longitude;
-  }
-
-  public int getNumber() {
-    return number;
-  }
-
-  public double getLatitude() {
-    return latitude;
-  }
-
-  public double getLongitude() {
-    return longitude;
-  }
-
-  public String[] getTypeArray() {
-    return typeArray;
-  }
-
-  public String getName() {
-    return name;
-  }
-
-  public void setName(String name){
-    this.name=name;
-  }
-
-  public void setType(String type){
-    if(typeArray == null){
-      this.typeArray = new String[6];
-    }
-    this.setInFreeSpace(type,this.getTypeArray());
-  }
-
-  private void setInFreeSpace(String type, String[] typeArray){
-    for(int i = 0; i<typeArray.length; i++){
-      if(typeArray[i]==null){
-        typeArray[i]=type;
-        i=typeArray.length;
-      }
-    }
-  }
-
-  public boolean isTypeOf(String typeName){
-    return Arrays.stream(typeArray).anyMatch(t -> t.equalsIgnoreCase(typeName));
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (this == o) return true;
-    if (!(o instanceof NewNode node)) return false;
-    return number == ((NewNode) o).getNumber();
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(number);
-  }
-}
-
-class NewEdge implements Comparable<NewEdge>{
-  private final int start;
-  private final int destination;
-  private final int drivingTime;
-  private final int distance;
-  private final int speedLimit;
-
-  public NewEdge(int start, int destination, int drivingTime, int distance, int speedLimit) {
-    this.start = start;
-    this.destination = destination;
-    this.drivingTime = drivingTime;
-    this.distance = distance;
-    this.speedLimit = speedLimit;
-  }
-
-  public int getStart() {
-    return start;
-  }
-
-  public int getDestination() {
-    return destination;
-  }
-
-  public int getDrivingTime() {
-    return drivingTime;
-  }
-
-  public int getDistance() {
-    return distance;
-  }
-
-  public int getSpeedLimit() {
-    return speedLimit;
-  }
-
-  @Override
-  public int compareTo(NewEdge o) {
-    return Integer.compare(this.getDrivingTime(),o.getDrivingTime());
-  }
-}
-
-class NewGraph{
-  private final List<Node> nodes = new ArrayList<>();
-  private final List<List<NewEdge>> neighbourList = new ArrayList<>();
-
-  public void setNodes(int number, double longitude, double latitude){
-    nodes.add(number, new Node(number,latitude,longitude));
-  }
-
-  public void readAllNodes(List<String> data){
-    for (int i = 1; i<data.size(); i++){
-      //System.out.println(data.get(i));
-      String [] splitText = Utils.dividedText(data.get(i),3);
-      //System.out.println(Arrays.toString(splitText));
-      this.setNodes(Integer.parseInt(splitText[0]),Double.parseDouble(splitText[1]),Double.parseDouble(splitText[2]));
-    }
-  }
-
-  public void readAllEdges(List<String> data){
-    for(int j = 0; j < Integer.parseInt(Utils.splitText(data.get(0),1)[0]);j++){
-      neighbourList.add(new ArrayList<>());
-    }
-    for(int i = 1 ; i<data.size();i++){
-      String [] splitText = Utils.dividedText(data.get(i),5);
-      neighbourList.get(i-1).add(new NewEdge(Integer.parseInt(splitText[0]),Integer.parseInt(splitText[1])
-          ,Integer.parseInt(splitText[2]),Integer.parseInt(splitText[3])
-          ,Integer.parseInt(splitText[4])));
-    }
-  }
-
-
-}