在我将相同的listArray传递给下一个函数之后，将listArray传递给了函数是有问题的。第一个索引处的项目丢失。

我试图在函数中查找问题，以查看是否在函数中。但是在测试检查通过的Collection之后，问题出在参数传递上。

   public static void main(String[] args){
    List<Process> listArray = new ArrayList<Process>(); // The `Process` here is user defined datatype

    ***some loop code to get an input from the user...

    Chart(listArray);
    List<Process> fcfsListArray = new ArrayList<Process>(fcfsScheduling(listArray));
        for(Process k : listArray){
            System.out.println(k.getProcessname()); // TEST CHECK fcfs
        } 
        List<Process> sjfNpListArray = new ArrayList<Process>(sjfNpScheduling(listArray));
        for(Process k : listArray){
            System.out.println(k.getProcessname()); // TEST CHECK sjfNp
        }
        //some functions...
}

public static List<Process> fcfsScheduling(List<Process> listArray){

    int n = listArray.size();
    int timeFrame = startingTimeFrame(listArray);
    int processCompleted = 0;

    while(processCompleted != n){
        for(int index = 0  ; index < n ; index ++){
            Process currentProcessor  = listArray.get(index);

            boolean isFinished = currentProcessor.getisCompleted();
            if(isFinished != true){
                int currentArrival = currentProcessor.getProcessArrival();
                if(currentArrival <=timeFrame){
                    currentProcessor.setProcessStart(timeFrame);
                    timeFrame+=currentProcessor.getProcessBurst();          // Sets the time frame where the current process will end.
                    currentProcessor.setProcessEnd(timeFrame);
                    currentProcessor.setisCompleted(true);
                    computeWaitingTime(currentProcessor);                   // compute for the waiting time of the processor;
                    listArray.set(index,currentProcessor);
                    processCompleted += 1;
                }
            }
        }
    }
        return listArray;

}
public static List<Process> sjfNpScheduling(List<Process> listArray){
        int n  = listArray.size();
        int processCompleted = 0;
        int timeFrame = startingTimeFrame(listArray);

        // Loop until all processors are completely finished
        while(processCompleted != n){

            Process toProcess  = new Process();
            int processIndex = 0;
            int leastBurstTime = Integer.MAX_VALUE;

           // Find for the PROCESS with the least ARRIVAL TIME and BURST TIME 
           for(int i = 0 ; i < listArray.size(); i++){
                Process currentProcess = listArray.get(i);
                int processBurst = currentProcess.getProcessBurst();
                int processArrival = currentProcess.getProcessArrival();
                boolean isCompleted = currentProcess.getisCompleted();
                if(isCompleted != true){
                    if(processBurst < leastBurstTime && processArrival <= timeFrame){
                        toProcess = currentProcess;
                        leastBurstTime = processBurst;
                        processIndex = i;
                    }
                }   
           }
           int processBurstTime = toProcess.getProcessBurst();

           toProcess.setProcessStart(timeFrame);
           timeFrame+=processBurstTime;
           toProcess.setProcessEnd(timeFrame);
           toProcess.setisCompleted(true);
           computeWaitingTime(toProcess);
           listArray.set(processIndex,toProcess);
           processCompleted += 1;

        }
        return listArray;
    }
public static int startingTimeFrame(List<Process> listArray){
        int n = listArray.size();
        int leastTime = Integer.MAX_VALUE;

        for(int x = 0; x < n; x++){
            int arrivalTime  = listArray.get(x).getProcessArrival();    
            if(arrivalTime < leastTime) leastTime = arrivalTime;
        }
        return leastTime;
    }
public static void Chart(List<Process> listArray){
           System.out.println("=================================================");
           System.out.println("|++++++++++++++++ PROCESS CHART ++++++++++++++++|");
           System.out.println("=================================================");
           System.out.println();

           int n = listArray.size();
           int matSizeRow = n + 1;
           String[][] matChart = new String[matSizeRow][3];
            matChart[0][0] = "\t Process";
            matChart[0][1] = "\t Burst";
            matChart[0][2] = "\t Arrival \t";

           for(int x = 0; x < n;x++){
               Process currentProcess = listArray.get(x);
               int index = x+1;
               matChart[index][0] = "\t "+currentProcess.getProcessname();
               matChart[index][1] = "\t\t "+Integer.toString(currentProcess.getProcessBurst());
               matChart[index][2] = "\t\t "+Integer.toString(currentProcess.getProcessArrival()) +" \t";

            }
           for(String[] row :matChart){
               System.out.println(Arrays.toString(row));
               System.out.println();
           }
       }
//USER DEFINED DATATYPE : PROCESS

public class Process{
    private String processname;
    private  int processBurst;
    private int processArrival;
    private int processpriority;
    private int processStart;
    private int processEnd;
    private double waitingTime = 0;
    private boolean isCompleted = false;


public void setProcesspriority(int n){
    this.processpriority = n;
}
public int getProcesspriority(){
    return this.processpriority;
}
public void setisCompleted(boolean condition){
    this.isCompleted = condition;
}
public boolean getisCompleted(){
    return this.isCompleted;
}
public void setWaitingTime(double objStart){
    this.waitingTime = objStart;
}
public double getWaitingTime(){
    return this.waitingTime;
}
public void setProcessStart(int objStart){
    this.processStart = objStart;
}
public int getProcessStart(){
    return this.processStart;
}
public void setProcessEnd(int n){
    this.processEnd = n;
}
public int getProcessEnd(){
    return this.processEnd;
}
public void setProcessname(String objName){
    this.processname = objName;
}
public String getProcessname(){
    return this.processname;
}
public void setProcessBurst(int objBurst){
    this.processBurst = objBurst;
}
public int getProcessBurst(){
    return this.processBurst;
}
public void setProcessArrival(int objArrival) {
    this.processArrival= objArrival;
} 
public int getProcessArrival(){
    return this.processArrival;
}
}

假设我在listArray中输入了3个Process变量，每个变量都有一个名称p1,p2,p3

在listArray第一次传递给Chart函数的过程中，我通过显示listArray中每个Process变量的名称来检查项目，并且仍然可以使用。

Processname    
p1
p2
p3

同样在将listArray传递到fcfsScheduling之前，它仍然可以使用。 （TEST CHECK fcfs的输出）

p1
p2
p3

当它在sjfNpScheduling中传递时，输出为：

null
p2
p3

更新： 据说问题出在sjfNpscheduling函数调用中，但是在通过删除fcfsScheduling调用调试代码之后，sjfNpScheduling起作用了。

p1
p2
p3

对于方法中的参数，是否有两个以上的传递给List Collection的限制？