Java Method Definition is Slowing Execution Considerably

Question

I am currently learning Java. Below is a list of methods from a simple Java program I have written. Is there anything that stands out in these methods would cause the execution of the program to go very slow? It's taking four seconds to execute using an array containing just 6 integers:

EDITED: here's the entire program as requested. I wrote it in Textpad. I realise it is not the most efficient algorithm. It does what it is supposed to do, but takes too long to do it.

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)

This line is incrementing n instead of i. it will loop until n overflows. It should be:

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

Because int arrays are initialized to 0 anyway, you can remove this loop completely.