Given the task of implementing the Pattern Builder for the Dijkstra algorithm, so that the Graph object is immutable , and there are methods for finding the shortest path. I wrote this misunderstanding, but I am very unhappy with the code, tell me how it can be optimized or changed so that when you create a graph, you can simply make Graph graph = new Graph().edge(1, 2 ,44).edge(1, 3, 65)...build();
public class Edge { private final Vertex start; private final Vertex finish; private final int weight; public Edge(String laneId, Vertex source, Vertex destination, int weight) { this.start = source; this.finish = destination; this.weight = weight; } public Vertex getFinish() { return finish; } public Vertex getStart() { return start; } public int getWeight() { return weight; } } public class Vertex { final private String id; final private String name; public Vertex(String id, String name) { this.id = id; this.name = name; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((id == null) ? 0 : id.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Vertex other = (Vertex) obj; if (id == null) { if (other.id != null) return false; } else if (!id.equals(other.id)) return false; return true; } @Override public String toString() { return name; } } public class Dejkstra { private final List<Vertex> nodes; private final List<Edge> edges; private Set<Vertex> settledNodes; private Set<Vertex> unSettledNodes; private Map<Vertex, Vertex> predecessors; private Map<Vertex, Integer> distance; public Dejkstra(Graph graph) { this.nodes = new ArrayList<Vertex>(graph.getVertexes()); this.edges = new ArrayList<Edge>(graph.getEdges()); } public void execute(Vertex source) { settledNodes = new HashSet<Vertex>(); unSettledNodes = new HashSet<Vertex>(); distance = new HashMap<Vertex, Integer>(); predecessors = new HashMap<Vertex, Vertex>(); distance.put(source, 0); unSettledNodes.add(source); while (unSettledNodes.size() > 0) { Vertex node = getMinimum(unSettledNodes); settledNodes.add(node); unSettledNodes.remove(node); findMinimalDistances(node); } } private void findMinimalDistances(Vertex node) { List<Vertex> adjacentNodes = getNeighbors(node); for (Vertex target : adjacentNodes) { if (getShortestDistance(target) > getShortestDistance(node) + getDistance(node, target)) { distance.put(target, getShortestDistance(node) + getDistance(node, target)); predecessors.put(target, node); unSettledNodes.add(target); } } } private int getDistance(Vertex node, Vertex target) { for (Edge edge : edges) { if (edge.getStart().equals(node) && edge.getFinish().equals(target)) { return edge.getWeight(); } } throw new RuntimeException("Should not happen"); } private List<Vertex> getNeighbors(Vertex node) { List<Vertex> neighbors = new ArrayList<Vertex>(); for (Edge edge : edges) { if (edge.getStart().equals(node) && !isSettled(edge.getFinish())) { neighbors.add(edge.getFinish()); } } return neighbors; } private Vertex getMinimum(Set<Vertex> vertexes) { Vertex minimum = null; for (Vertex vertex : vertexes) { if (minimum == null) { minimum = vertex; } else { if (getShortestDistance(vertex) < getShortestDistance(minimum)) { minimum = vertex; } } } return minimum; } private boolean isSettled(Vertex vertex) { return settledNodes.contains(vertex); } private int getShortestDistance(Vertex destination) { Integer d = distance.get(destination); if (d == null) { return Integer.MAX_VALUE; } else { return d; } } public LinkedList<Vertex> getPath(Vertex target) { LinkedList<Vertex> path = new LinkedList<Vertex>(); Vertex step = target; if (predecessors.get(step) == null) { return null; } path.add(step); while (predecessors.get(step) != null) { step = predecessors.get(step); path.add(step); } Collections.reverse(path); return path; } } public class Graph { private final List<Vertex> vertexes; private final List<Edge> edges; public List<Edge> getEdges() { return edges; } public List<Vertex> getVertexes(){ return vertexes; } public static class Builder { private List<Vertex> vertexes; private List<Edge> edges; public Builder edge(List<Vertex> vertexes, List<Edge> edges) { this.vertexes = vertexes; this.edges = edges; return this; } public Graph build() { return new Graph(this); } } Graph(Builder builder) { vertexes = builder.vertexes; edges = builder.edges; } } public class Test { private List<Vertex> nodes; private List<Edge> edges; @org.junit.Test public void testExcute() { nodes = new ArrayList<Vertex>(); edges = new ArrayList<Edge>(); for (int i = 0; i < 12; i++) { Vertex location = new Vertex("Node_" + i, "Node_" + i); nodes.add(location); } addLane("Edge_0", 1, 2, 70); addLane("Edge_1", 1, 3, 140); addLane("Edge_2", 1, 4, 120); addLane("Edge_3", 2, 5, 130); addLane("Edge_4", 3, 4, 80); addLane("Edge_5", 3, 6, 100); addLane("Edge_6", 4, 5, 140); addLane("Edge_7", 4, 6, 100); addLane("Edge_8", 4, 8, 150); addLane("Edge_9", 5, 7, 150); addLane("Edge_10", 6, 7, 170); addLane("Edge_11", 6, 8, 70); addLane("Edge_12", 7, 8, 90); Graph graph = new Graph.Builder().edge(nodes, edges).build(); Dejkstra dijkstra = new Dejkstra(graph); dijkstra.execute(nodes.get(0)); LinkedList<Vertex> path = dijkstra.getPath(nodes.get(7)); assertNotNull(path); assertTrue(path.size() > 0); for (Vertex vertex : path) { System.out.println(vertex); } } private void addLane(String laneId, int sourceLocNo, int destLocNo, int duration) { Edge lane = new Edge(laneId, nodes.get(sourceLocNo), nodes.get(destLocNo), duration); edges.add(lane); } public static void main(String[] args) throws IOException { } } 
