Javaメソッドの定義が遅く実行されています

Question

現在Javaを学習中です。以下は、私が書いた簡単なJavaプログラムのメソッドリストです。これらの方法で目立つものがあれば、プログラムの実行が非常に遅くなるでしょうか？これは、ちょうど6つの整数を含む配列を使用して実行するのに4秒かかる。

EDITED：要求されたプログラム全体がここにある。私はTextpadでそれを書きました。私はそれが最も効率的なアルゴリズムではないことを認識しています。それはやるべきことをしますが、それを行うには時間がかかります。

import java.util.*; 
public class Supermarket 
{ 
    public static void main(String [] args) 
    { 
     int[] custTimes = 
     { 
      1, 6, 7, 4, 4, 3, 5, 1, 2, 1, 3, 6, 4 
     }; 

     int checkOuts = 6; 
     int answer; 
     answer = Solution.solveSuperMarketQueue(custTimes, checkOuts); 
     System.out.println("Answer is " + answer); 
    } 
}//~public class Supermarket... 

class Solution 
{ 
    static int myTotal; 
    static int solveSuperMarketQueue(int[] customers, int n) 
    { 
     // ******************* INITIALIATION *********************** 
     myTotal = 0; 
     int len = customers.length; // length of customer queue 
     if (len < 1) 
     { 
      return 0; 
     } 
     int[] till = new int[n]; // array to store all tills and till queues 
     int tillMin; // Minimum time 
     int tillMax; // Maximum time 

     // Put the customers into an arraylist: 
     ArrayList<Integer> times = new ArrayList<Integer>(); 
     for (int i = 0; i < len; i = i + 1) 
     { 
      times.add(i, customers[i]); 
     } 

     // create the array of tills and set all queue intial values to 0 
     for (int i = 0; i < n; n = n + 1) 
     { 
      till[i] = 0; 
     } 
     // Move the queue to tills to start off 
     ReturnPair result = copyQueue(till, times); 
     till = result.getArr(); 
     times = result.getList(); 
     int s = times.size(); 

     tillMax = getMaxTime(till); 
     tillMin = getMinTime(till); 

     // ***************** END OF INITIALIATION ****************** 

     // *****************MAIN LOOP ****************************** 


     while (tillMax > 0) 
     { 
      // Find customer(s) with least time use that time to move all queues 
      // and update myTotal time. 
      // STEP 1: get minimum time in tills array (ignore zero) 
      tillMin = getMinTime(till); 
      // STEP 2: subtract minimum value from all the tills, but not if till has a zero 
      if (tillMin > 0) 
      { 
       till = subtractTime(till, tillMin); 
      } 
      // Move the queue to tills 
      if (s > 0) 
      { 
       result = copyQueue(till, times); 
       till = result.getArr(); 
       times = result.getList(); 
      } 

      tillMax = getMaxTime(till); 
      tillMin = getMinTime(till); 
     } 
     return myTotal; 

     // **************** END OF LOOP ***************************** 

    }//~public static int solveS... 


    // ****************** METHODS ********************************** 

    // Method to move queue foward 
    // For each till, a time is copied from the customer array. 
    // The values are copied in order. 
    // The value is coped only if array value is zero. 
    private static ReturnPair copyQueue(int[] arr, ArrayList<Integer> arrList) 
    { 
     int n = arr.length; // for each till... 
     for (int i = 0; i < n; i = i + 1) 
     { 
      if (arr[i] == 0 && arrList.size() > 0) // only copy if it current till value is 0 AND arrayList value exists 
      { 
       arr[i] = arrList.get(0); 
       arrList.remove(0); 
      } 
     } 

     // returns an instance of the object myResult which is a container for an array and an arraylist 
     return new ReturnPair(arr, arrList); 
    } 

    // Method to get minimum time from array (but not zero). 
    private static int getMinTime(int[] arr) 
    { 
     int minValue = 0; 

     // make sure arr[i] isn't zero. 
     for (int i = 0; i < arr.length; i = i + 1) 
     { 
      if (arr[i] != 0) 
      { 
       minValue = arr[i]; 
       break; 
      } 
     } 

     // Find minimum value that isn't zero. 
     for (int i = 1; i < arr.length; i = i + 1) 
     { 
      if (arr[i] != 0 && arr[i] < minValue) 
      { 
       minValue = arr[i]; 
      } 
     } 
     return minValue; 
    }//~static int getMinTime(in... 

    // Method to subtract minimum time from tills 
    private static int[] subtractTime(int[] arr, int min) 
    { 
     int n = arr.length; 
     for (int i = 0; i < n; i = i + 1) 
     { 
      if (arr[i] != 0) 
      { 
       arr[i] = arr[i] - min; 
      } 
     } 
     // update myTotal 
     myTotal = myTotal + min; 
     return arr; 
    }//~static void subtractTime... 

    private static int getMaxTime(int[] arr) 
    { 
     int maxValue = arr[0]; 
     for (int i = 1; i < arr.length; i = i + 1) 
     { 
      if (arr[i] > maxValue) 
      { 
       maxValue = arr[i]; 
      } 
     } 
     return maxValue; 
    } 
}//~class Solution... 

// Special class designed to return an array and an array list as an object 
class ReturnPair 
{ 
    // set up fields 
    int[] newArr; 
    ArrayList<Integer> newArrList; 

    // define method 
    public ReturnPair(int[] first, ArrayList<Integer> second) 
    { 
     this.newArr = first; 
     this.newArrList = second; 
    } 

    public int[] getArr() 
    { 
     return newArr; 
    } 

    public ArrayList<Integer> getList() 
    { 
     return newArrList; 
    } 
} 

Answer 1

for (int i = 0; i < n; n = n + 1) 

この行ではなくiのnをインクリメントされます。 nがオーバーフローするまでループします。それは次のようになります。

for (int i = 0; i < n; i++) 

int型の配列がとにかく0に初期化されているので、あなたは完全にこのループを削除することができます。