Job Scheduling(topological sort)

package testrun;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;

public class TopologicalSort {

    public static class JobNode {
        int                jobId;
        ArrayList<JobNode> dependies          = new ArrayList<JobNode>();
        int                noOfPrerequisitive = 0;

        public JobNode(int jobId) {
            super();
            this.jobId = jobId;
        }

        public void addDep(JobNode n) {
            if (dependies == null) {
                dependies = new ArrayList<JobNode>();

            }
            dependies.add(n);
        }

        public int getJobId() {
            return jobId;
        }

        public void setJobId(int jobId) {
            this.jobId = jobId;
        }

        public ArrayList<JobNode> getDependies() {
            return dependies;
        }

        public void setDependies(ArrayList<JobNode> dependies) {
            this.dependies = dependies;
        }

        public int getNoOfPrerequisitive() {
            return noOfPrerequisitive;
        }

        public void setNoOfPrerequisitive(int noOfPrerequisitive) {
            this.noOfPrerequisitive = noOfPrerequisitive;
        }

    }

    public static class JobGraph {
        ArrayList<JobNode>        nodes = new ArrayList<JobNode>();
        HashMap<Integer, JobNode> map   = new HashMap<Integer, JobNode>();

        public JobGraph(ArrayList<Integer> jobs) {
            for (int j : jobs) {
                map.put(j, new JobNode(j));
                nodes.add(map.get(j));
            }

        }

        public void addNode(Integer j) {
            map.put(j, new JobNode(j));
            nodes.add(map.get(j));
        }

        public void addDependies(Integer j, Integer d) {
            JobNode job = getNode(j);
            JobNode dep = getNode(d);
            if (job.dependies == null) {
                job.dependies = new ArrayList<JobNode>();
            }
            job.dependies.add(dep);
            dep.noOfPrerequisitive++;
        }

        public JobNode getNode(Integer n) {
            if (!map.containsKey(n)) {
                addNode(n);
            }

            return map.get(n);
        }

        public ArrayList<JobNode> getNodes() {
            return nodes;
        }

        public void setNodes(ArrayList<JobNode> nodes) {
            this.nodes = nodes;
        }

        public HashMap<Integer, JobNode> getMap() {
            return map;
        }

        public void setMap(HashMap<Integer, JobNode> map) {
            this.map = map;
        }

    }

    public static ArrayList<Integer> topologicalSort(ArrayList<Integer> jobs, ArrayList<Integer[]> deps) {
        ArrayList<Integer> jobsInOrder = new ArrayList<Integer>();
        JobGraph graph = new JobGraph(jobs);
        for (Integer[] d : deps) {
            graph.addDependies(d[0], d[1]);
        }
        ArrayList<JobNode> jobWithNoPreq = new ArrayList<JobNode>();

        // get the indenpendent jobs first
        for (JobNode job : graph.nodes) {
            if (job.noOfPrerequisitive == 0) {
                jobWithNoPreq.add(job);
            }
        }
        // traverse till independent jobs are done
        while (!jobWithNoPreq.isEmpty()) {
            int lastIndex = jobWithNoPreq.size() - 1;
            JobNode node = jobWithNoPreq.get(lastIndex);
            jobWithNoPreq.remove(lastIndex);
            // add curent in final list
            jobsInOrder.add(node.jobId);
            // remove Dependents
            while (!node.dependies.isEmpty()) {
                int index = node.dependies.size() - 1;
                JobNode dep = node.dependies.get(index);
                node.dependies.remove(index);
                dep.noOfPrerequisitive--;
                if (dep.noOfPrerequisitive == 0) {
                    jobWithNoPreq.add(dep);
                }
            }
        }

        boolean isGraphHasCycle = false;
        // ig any veritices still has edges
        for (JobNode node : graph.nodes) {
            if (node.noOfPrerequisitive > 0) {
                isGraphHasCycle = true;
                break;
            }
        }
        return isGraphHasCycle ? new ArrayList<Integer>() : jobsInOrder;
    }

    public static void main(String[] args) {
        ArrayList<Integer> jobs = new ArrayList<Integer>(Arrays.asList(1, 2, 3, 4));
        Integer[][] depsArray = new Integer[][] { { 1, 2 }, { 1, 3 }, { 3, 2 }, { 4, 2 }, { 4, 3 } };
        ArrayList<Integer[]> deps = new ArrayList<Integer[]>();
        fillDeps(depsArray, deps);
        ArrayList<Integer> order = topologicalSort(jobs, deps);
        System.out.print(order);
    }

    static void fillDeps(Integer[][] depsArray, ArrayList<Integer[]> deps) {
        for (Integer[] depArray : depsArray) {
            deps.add(depArray);
        }
    }

}