BellmanFord Algorithm in Java

App.java

import java.util.ArrayList;
import java.util.List;

public class App {
    public static void main(String[] args) {
        List<Vertex> vertexList = new ArrayList<>();

        vertexList.add(new Vertex("A"));
        vertexList.add(new Vertex("B"));
        vertexList.add(new Vertex("C"));
        vertexList.add(new Vertex("D"));

        List<Edge> edgeList = new ArrayList<>();

        edgeList.add(new Edge(1, vertexList.get(0), vertexList.get(1)));
        edgeList.add(new Edge(1, vertexList.get(1), vertexList.get(2)));
        edgeList.add(new Edge(1, vertexList.get(2), vertexList.get(3)));
//        edgeList.add(new Edge(-5, vertexList.get(3), vertexList.get(1))); // negative case
        edgeList.add(new Edge(10, vertexList.get(0), vertexList.get(3)));

        BellmanFord algorithm = new BellmanFord(edgeList, vertexList);
        algorithm.shotestPath(vertexList.get(0), vertexList.get(3));
    }
}

BellmanFord.java

import java.util.List;

public class BellmanFord {
    private List<Vertex> vertexList;
    private List<Edge> edgeList;

    public BellmanFord(List<Edge> edgeList, List<Vertex> vertexList) {
        this.vertexList = vertexList;
        this.edgeList = edgeList;
    }

    public void shotestPath(Vertex sourceVertex, Vertex targetVertex) {
        sourceVertex.setMinDistance(0);

        int length = this.vertexList.size();

        for (int i = 0; i < length - 1; i++) {
            for (Edge edge : this.edgeList) {

                if (edge.getStartVertex().getMinDistance() == Double.MAX_VALUE) {
                    continue;
                }

                Vertex v = edge.getStartVertex();
                Vertex u = edge.getTargetVertex();

                double newDistance = v.getMinDistance() + edge.getWeight();

                if (newDistance < u.getMinDistance()) {
                    u.setMinDistance(newDistance);
                    u.setPreviousVertex(v);
                }
            }
        }

        for (Edge edge : this.edgeList) {
            if (edge.getStartVertex().getMinDistance() != Double.MAX_VALUE) {
                if (hasCycle(edge)) {
                    System.out.println("There is a negative cycle...");
                }
            }
        }

        if (targetVertex.getMinDistance() == Double.MAX_VALUE) {
            System.out.println("There is no path at all to target from source...");
        } else {
            System.out.println("Shortest path is: " + targetVertex.getMinDistance());
        }

    }

    private boolean hasCycle(Edge edge) {
        return (edge.getStartVertex().getMinDistance() + edge.getWeight()) < edge.getTargetVertex().getMinDistance();
    }
}

Edge.java

public class Edge {
    private double weight;
    private Vertex startVertex;
    private Vertex targetVertex;

    public Edge(double weight, Vertex startVertex, Vertex targetVertex) {
        this.weight = weight;
        this.startVertex = startVertex;
        this.targetVertex = targetVertex;
    }

    public double getWeight() {
        return weight;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }

    public Vertex getStartVertex() {
        return startVertex;
    }

    public void setStartVertex(Vertex startVertex) {
        this.startVertex = startVertex;
    }

    public Vertex getTargetVertex() {
        return targetVertex;
    }

    public void setTargetVertex(Vertex targetVertex) {
        this.targetVertex = targetVertex;
    }
}

Vertex.java

import java.util.ArrayList;
import java.util.List;

public class Vertex {
    private String name;
    private boolean visited;
    private List<Edge> edges;
    private double minDistance = Double.MAX_VALUE;
    private Vertex previousVertex;

    public Vertex(String name) {
        this.name = name;
        this.edges = new ArrayList<>();
    }

    public void addAdge(Edge edge) {
        this.edges.add(edge);
    }

    public boolean isVisited() {
        return visited;
    }

    public void setVisited(boolean visited) {
        this.visited = visited;
    }

    public List<Edge> getEdges() {
        return edges;
    }

    public void setEdges(List<Edge> edges) {
        this.edges = edges;
    }

    public double getMinDistance() {
        return minDistance;
    }

    public void setMinDistance(double minDistance) {
        this.minDistance = minDistance;
    }

    public Vertex getPreviousVertex() {
        return previousVertex;
    }

    public void setPreviousVertex(Vertex previousVertex) {
        this.previousVertex = previousVertex;
    }
}