logic behind the code

public interface ProcessSchedular {
    //here all the abstract methods are implemented

    public abstract int[] calculateTurnAroundTime(int[] burstTime,int[] arrivalTime);
    public abstract int[] calculateResponseTime(int[] burstTime, int[] arrivalTime);
    public abstract int[] calculateWaitingTime(int[] burstTime, int[] arrivalTime);
    public abstract double calculateAvgTurnAroundTime(int[] turnAroundTime);
    public abstract double calculateAvgWaitingTime(int[] waitingTime);


}

/*
The algorithm for the FCFS is programmed here
 */

package lk.ac.kln.cal.FCFS;

public class FirstComeFirstServe implements ProcessSchedular {

    @Override
    public int[] calculateTurnAroundTime(int[] burstTime,int[] arrivalTime) {
        //Once this method is called by the CPU, the turn arround times will be generated
        //In FCFS the turn around time is the sum of waiting time + I/O waiting time + burst time
        int length = burstTime.length;
        int[] waitingTime = calculateWaitingTime(burstTime,arrivalTime);
        int[] turnArroundTime = new int[length];


        turnArroundTime[0] = burstTime[0];

        for(int i = 1; i<length; i++){
            turnArroundTime[i] = burstTime[i]+waitingTime[i];
        }
        return turnArroundTime;

    }

    @Override
    public int[] calculateResponseTime(int[] burstTime,int[] arrivalTime) {
        // this method is responsible for calculating response time
        // the time that each process takes to generate its first out put since the zero
        int length = burstTime.length;
        int[] responseTime = new int[length];

        responseTime[0] = arrivalTime[0];

        for(int i = 1; i<length; i++){
            responseTime[i] = responseTime[i-1]+burstTime[i-1];
        }
        return responseTime;
    }


    @Override
    public int[] calculateWaitingTime(int[] burstTime, int[] arrivalTime) {
        /*this method calculates the waiting time of a process. Basically we defined that the waiting time
        of the first process is almost zero
         */

        int length = burstTime.length;
        int[] waitingtTime = new int[length];
        //waitingtTime[0] = 0;

        int [] responseTime = calculateResponseTime(burstTime,arrivalTime);
        for( int i = 0; i<length; i++){
            waitingtTime[i] = responseTime[i] - arrivalTime[i];
        }
        return waitingtTime;
    }



    @Override
    public double calculateAvgTurnAroundTime(int[] turnAroundTime) {
        //this method is created for calculating the average turn around time
        double totalTurnAroundTime = 0;
        double length = turnAroundTime.length;
        double avgTurnAroundTime ;

        for(int i = 0; i<length; i++){
            totalTurnAroundTime += turnAroundTime[i];
        }

        avgTurnAroundTime = totalTurnAroundTime/length;

        return avgTurnAroundTime;
    }


    @Override
    public double calculateAvgWaitingTime(int[] waitingTime) {
        //this method is created for calculating the average turn around time
        double totolWaitingTime = 0;
        double length = waitingTime.length;
        double avgWaitingTime ;

        for (int i = 0; i<length; i++){
            totolWaitingTime += waitingTime[i];
        }

        avgWaitingTime = totolWaitingTime/length;

        return avgWaitingTime;
    }


}

/*
This is a simple program that simulates the process of CPU scheduling, specially this program
implements the process of First Serve First Come algorithm , but this whole program with all the classes are designed to
adapt any of the CPU Scheduling algorithms.
As you see, the FirstComeFirstServe class implements the ProcessSchedular interface, In this way we can adapt more scheduling algorithms
to the ProcessSchedular interface and that can be used by this CPU class.

CTEC 21032

programmed by:- Mahesh M.G.H
Reg No: - CT/2016/041

 */


package lk.ac.kln.cal.FCFS;

import java.util.Arrays;
import java.util.Scanner;

public class CPU {

    public static void main(String[] args) {

        // This is for getting the number of processors from the user
        System.out.print("Enter number of processes: ");
        Scanner getNumberOfProcessors = new Scanner(System.in);
        int numberOFProc = getNumberOfProcessors.nextInt();


        //This is for getting the important details(Arrival time, burst time) of process
        System.out.print("Enter each process arrival time (ms) and CPU burst: ");
        Scanner getProcessDetails = new Scanner(System.in);
        String ProcessDetails = getProcessDetails.nextLine();

        // Here the inputed details of a process is splited into an array that can be used to further split as burst time and arrival time
        String[] ProcessDetailsArray = new String[numberOFProc];
        ProcessDetailsArray = ProcessDetails.split(" \\| ");

//***here i assume that the user enters the details of processes in acsending order of their arrival time,if it is not then a sorting algorithm should be used***

        //creating arrays for storing arrival time and the burst time of a process
        int[] ProcessArrivalTime = new int[numberOFProc];
        int[] ProcessBurstTime = new int[numberOFProc];


        //this for loop is used for storing the arrival time of a process
        for(int i = 0; i <numberOFProc; i++){
            /*In here a little bit conversion between a String and an Integer is happened,
            I extract the corresponding arrival time for a process that is stored in the ProcessDetailsArray and store it in the
            ProcessArrivalArray
             */
            String temp[] = ProcessDetailsArray[i].split("\\,");  // since the arrival time is stored as the 0th character of the item, I used the temp array to split it by ','
            ProcessArrivalTime[i] = Integer.parseInt(temp[0]);

        }



        //this for loop is used for storing the burst time of a process
        for(int i = 0; i <numberOFProc; i++) {
            /*In here a little bit conversion between a String and an Integer is happened,
            I extract the corresponding arrival time for a process that is stored in the ProcessDetailsArray and store it in the
            ProcessArrivalArray
             */
            String temp[] = ProcessDetailsArray[i].split("\\,");  // since the arrival time is stored as the 0th character of the item, I used the temp array to split it by ','
            ProcessBurstTime[i] = Integer.parseInt(temp[1]);
        }


            //scheduling the processes according to the FCFS algorithm
            ProcessSchedular processSchedular = new FirstComeFirstServe();

            //calculating the turn arround time
            int[] turnAroundTime =  processSchedular.calculateTurnAroundTime(ProcessBurstTime,ProcessArrivalTime);

            //calculating the response time
            int[] responceTime = processSchedular.calculateResponseTime(ProcessBurstTime,ProcessArrivalTime);

            //calculating the waiting time
            int[] waitingTime = processSchedular.calculateWaitingTime(ProcessBurstTime,ProcessArrivalTime);

            //calculating the average turn arround time
            double avgTurnAroundTime = processSchedular.calculateAvgTurnAroundTime(turnAroundTime);

            //calculating the average waiting time
            double avgWaitingTime = processSchedular.calculateAvgWaitingTime(waitingTime);

            //This is the output process of this program

            System.out.println("Process     |Turnaround time     |Response time     |Waiting time");

            for(int i = 0; i<numberOFProc; i++){
                int ta = turnAroundTime[i];
                int rt = responceTime[i];
                int wt = waitingTime[i];

                System.out.println((i+1)+"\t\t\t\t"+ta+"\t\t\t\t\t"+rt+"\t\t\t\t\t"+wt);

            }
        System.out.println("Average turnaround time: "+Math.round(avgTurnAroundTime)+"ms");
        System.out.println("Average waiting time: "+Math.round(avgWaitingTime)+"ms");

        }

    }