Why does it add on to the last one every time I run my program

Question

Basically, the question is to create a simulation for people waiting in line in a bank. There are certain criteria needed such as average waiting time, average number of minutes, average longest waiting time... etc. It also asks to run my program 3 times each a 1000 times (using a for loop). The issue is that each time I run the code, the answers are adding up for some reason and I can't seem to know why. For example, in the last run the number of times the simulation ran should be 1000 times, but instead it added all the previous runs together and gave 3000 times.

Also, all the variables outside the while loop (averageWaitingTime, averageSimulationTime... etc) are giving me wrong answers. It's because, for example, for the average waiting time, it keeps adding the same value of the waiting time. I can't figure out why.

 public class QueueSimulation {
    public static void main(String[] args) {
    Queue<Customer> q = new LinkedList<Customer>();

    int numServed = 0;
    int averageNumServed = 0;
    int waitingTime = 0;
    int maxWaitingTime = 0;
    int averageLongestWaitingTime = 0;
    int totalWaitingTime = 0;
    double averageWaitingTime = 0;
    int maxQueueSize = 0;
    int timeDone = 0;
    int totalSimulationTime = 0;
    int averageSimulationTime = 0;
    int numSimulationRan = 0;
    Random randomGenerator = new Random();
    int time = 0;
    int processingTime = 0;
    int totalProcessingTime = 0;

    for (int i = 0; i < 1000; i++) {

        double arrivalRate = 0.2;
        int maxProcessingTime = 5;

        while (time < 8 * 60) {
            if (Math.random() < 0.2) {
                System.out.println("A new customer arrives at time " + time);
                processingTime = randomGenerator.nextInt(maxProcessingTime);
                totalProcessingTime += processingTime;
                Customer c = new Customer(time, processingTime);
                q.add(c);
                if (q.size() > maxQueueSize)
                    maxQueueSize = q.size();
            }

            if (waitingTime > maxWaitingTime)
                maxWaitingTime = waitingTime;

            averageLongestWaitingTime += maxWaitingTime;

            // serve the next customer
            if (time > timeDone) // service is available
                if (!q.isEmpty()) {
                    Customer c = q.remove();
                    timeDone = time + c.getProcessingTime();
                    // calculate the waiting time of this customer
                    waitingTime = time - c.getArrivalTime();
                    // update total waiting time of all customers
                    totalWaitingTime += waitingTime;
                    // service this customer
                    numServed++;
                }
            time++;

            if (time > 8 * 60)
                while (!q.isEmpty()) {
                    Customer c = q.remove();
                    timeDone = time + c.getProcessingTime();
                    // calculate the waiting time of this customer
                    waitingTime = time - c.getArrivalTime();
                    // update total waiting time of all customers
                    totalWaitingTime += waitingTime;
                    // service this customer
                    numServed++;
                }
        }

        averageWaitingTime += (totalWaitingTime / numServed);
        totalSimulationTime = timeDone;
        averageSimulationTime += totalSimulationTime;
        averageNumServed += numServed;
        numSimulationRan += 1;
    }

    System.out.println();
    System.out.println("Average waiting time per customer: " + (double) averageWaitingTime / 1000);
    System.out.println("Average longest waiting time: " + (double) averageLongestWaitingTime / 1000);
    System.out.println("Average number of minutes: " + (double) averageSimulationTime / 1000);
    System.out.println("Longest waiting time: " + maxWaitingTime);
    System.out.println("Average number of customers " + (double) averageNumServed / 1000);
    System.out.println("Number of times the simulation ran: " + numSimulationRan);

    for (int j = 0; j < 1000; j++) {

        double arrivalRate = 0.5;
        int maxProcessingTime = 3;

        while (time < 8 * 60) {
            if (Math.random() < 0.5) {
                System.out.println("A new customer arrives at time " + time);
                processingTime = randomGenerator.nextInt(maxProcessingTime);
                totalProcessingTime += processingTime;
                Customer c = new Customer(time, processingTime);
                q.add(c);
                if (q.size() > maxQueueSize)
                    maxQueueSize = q.size();
            }

            if (waitingTime > maxWaitingTime)
                maxWaitingTime = waitingTime;

            averageLongestWaitingTime += maxWaitingTime;

            // serve the next customer
            if (time > timeDone) // service is available
                if (!q.isEmpty()) {
                    Customer c = q.remove();
                    timeDone = time + c.getProcessingTime();
                    // calculate the waiting time of this customer
                    waitingTime = time - c.getArrivalTime();
                    // update total waiting time of all customers
                    totalWaitingTime += waitingTime;
                    // service this customer
                    numServed++;
                }
            time++;

            if (time > 8 * 60)
                while (!q.isEmpty()) {
                    Customer c = q.remove();
                    timeDone = time + c.getProcessingTime();
                    // calculate the waiting time of this customer
                    waitingTime = time - c.getArrivalTime();
                    // update total waiting time of all customers
                    totalWaitingTime += waitingTime;
                    // service this customer
                    numServed++;
                }
        }

        averageWaitingTime += (totalWaitingTime / numServed);
        totalSimulationTime = timeDone;
        averageSimulationTime += totalSimulationTime;
        averageNumServed += numServed;
        numSimulationRan += 1;
    }

    System.out.println();
    System.out.println("Average waiting time per customer: " + (double) averageWaitingTime / 1000);
    System.out.println("Average longest waiting time: " + (double) averageLongestWaitingTime / 1000);
    System.out.println("Average number of minutes: " + (double) averageSimulationTime / 1000);
    System.out.println("Longest waiting time: " + maxWaitingTime);
    System.out.println("Average number of customers " + (double) averageNumServed / 1000);
    System.out.println("Number of times the simulation ran: " + numSimulationRan);

    for (int k = 0; k < 1000; k++) {

        double arrivalRate = 0.68;
        int maxProcessingTime = 4;

        while (time < 8 * 60) {
            if (Math.random() < 0.68) {
                System.out.println("A new customer arrives at time " + time);
                processingTime = randomGenerator.nextInt(maxProcessingTime);
                totalProcessingTime += processingTime;
                Customer c = new Customer(time, processingTime);
                q.add(c);
                if (q.size() > maxQueueSize)
                    maxQueueSize = q.size();
            }

            if (waitingTime > maxWaitingTime)
                maxWaitingTime = waitingTime;

            averageLongestWaitingTime += maxWaitingTime;

            // serve the next customer
            if (time > timeDone) // service is available
                if (!q.isEmpty()) {
                    Customer c = q.remove();
                    timeDone = time + c.getProcessingTime();
                    // calculate the waiting time of this customer
                    waitingTime = time - c.getArrivalTime();
                    // update total waiting time of all customers
                    totalWaitingTime += waitingTime;
                    // service this customer
                    numServed++;
                }
            time++;

            if (time > 8 * 60)
                while (!q.isEmpty()) {
                    Customer c = q.remove();
                    timeDone = time + c.getProcessingTime();
                    // calculate the waiting time of this customer
                    waitingTime = time - c.getArrivalTime();
                    // update total waiting time of all customers
                    totalWaitingTime += waitingTime;
                    // service this customer
                    numServed++;
                }
        }

        averageWaitingTime += (totalWaitingTime / numServed);
        totalSimulationTime = timeDone;
        averageSimulationTime += totalSimulationTime;
        averageNumServed += numServed;
        numSimulationRan += 1;
    }

    System.out.println();
    System.out.println("Average waiting time per customer: " + (double) averageWaitingTime / 1000);
    System.out.println("Average longest waiting time: " + (double) averageLongestWaitingTime / 1000);
    System.out.println("Average number of minutes: " + (double) averageSimulationTime / 1000);
    System.out.println("Longest waiting time: " + maxWaitingTime);
    System.out.println("Average number of customers " + (double) averageNumServed / 1000);
    System.out.println("Number of times the simulation ran: " + numSimulationRan);
}

}

Output:

A new customer arrives at time 5
A new customer arrives at time 10
A new customer arrives at time 11
A new customer arrives at time 12
A new customer arrives at time 25
A new customer arrives at time 28
A new customer arrives at time 31
A new customer arrives at time 45
A new customer arrives at time 48
A new customer arrives at time 51
A new customer arrives at time 59
A new customer arrives at time 64
A new customer arrives at time 68
A new customer arrives at time 86
A new customer arrives at time 100
A new customer arrives at time 106
A new customer arrives at time 108
A new customer arrives at time 113
A new customer arrives at time 115
A new customer arrives at time 120
A new customer arrives at time 124
A new customer arrives at time 125
A new customer arrives at time 126
A new customer arrives at time 132
A new customer arrives at time 137
A new customer arrives at time 153
A new customer arrives at time 156
A new customer arrives at time 164
A new customer arrives at time 201
A new customer arrives at time 206
A new customer arrives at time 208
A new customer arrives at time 219
A new customer arrives at time 226
A new customer arrives at time 233
A new customer arrives at time 234
A new customer arrives at time 237
A new customer arrives at time 242
A new customer arrives at time 246
A new customer arrives at time 247
A new customer arrives at time 251
A new customer arrives at time 262
A new customer arrives at time 271
A new customer arrives at time 276
A new customer arrives at time 277
A new customer arrives at time 282
A new customer arrives at time 285
A new customer arrives at time 287
A new customer arrives at time 292
A new customer arrives at time 296
A new customer arrives at time 298
A new customer arrives at time 318
A new customer arrives at time 319
A new customer arrives at time 327
A new customer arrives at time 336
A new customer arrives at time 337
A new customer arrives at time 338
A new customer arrives at time 346
A new customer arrives at time 355
A new customer arrives at time 356
A new customer arrives at time 358
A new customer arrives at time 362
A new customer arrives at time 363
A new customer arrives at time 366
A new customer arrives at time 374
A new customer arrives at time 379
A new customer arrives at time 380
A new customer arrives at time 384
A new customer arrives at time 389
A new customer arrives at time 400
A new customer arrives at time 407
A new customer arrives at time 416
A new customer arrives at time 418
A new customer arrives at time 424
A new customer arrives at time 427
A new customer arrives at time 433
A new customer arrives at time 436
A new customer arrives at time 437
A new customer arrives at time 438
A new customer arrives at time 446
A new customer arrives at time 454
A new customer arrives at time 466
A new customer arrives at time 469
A new customer arrives at time 471

Average waiting time per customer: 1.0
Average longest waiting time: 2.714
Average number of minutes: 475.0
Longest waiting time: 8
Average number of customers 83.0
Number of times the simulation ran: 1000

Average waiting time per customer: 2.0
Average longest waiting time: 2.714
Average number of minutes: 950.0
Longest waiting time: 8
Average number of customers 166.0
Number of times the simulation ran: 2000

Average waiting time per customer: 3.0
Average longest waiting time: 2.714
Average number of minutes: 1425.0
Longest waiting time: 8
Average number of customers 249.0
Number of times the simulation ran: 3000

Answer 1

There's a principle called Don't Repeat Yourself or DRY . Before the term was coined, we used to joke that laziness is a good quality in a programmer: if you have to do something twice you're doing it once too often.

Maybe you could look into declaring some methods because your program seems to have the same code three times.

Ironically, there's one thing you only do one time: initialize the statistics variables:

int numServed = 0;
...

If you copy this section and remove the types (so it reads numServed = 0; etc), and then copy that once more, it would reset these variables. However, copy-pasting code is bad practice: now you have 3 times as much code to maintain.

To fix this, you could structure your program like this:

 class QueueSimulation
 {
     public static void main(String[] args) {
        for ( int test = 0; test < 3; test ++ ) {
            int numServed = 0;
            ..
            for ( int i = 0; i < 1000; i++) {
               ...
            }
            System.out.println();
            ....     
        }
     }
 }

There's no duplicate code, and it localizes the variables so they are reset for each simulation - which fixes your problem.

This is only one step in the right direction. One more step is to factor out methods at abstraction levels , such as Top-Down and Bottom-Up design .
TLDR: A good rule of thumb is to have any method fit on one page of text .

In your case: you are running the same simulation 3 times. What the details of that simulation are doesn't matter to the method running the simulation 3 times.

Here's one other possible outline where we turned the variables into fields of the QueueSimulation class. To initialize them, we simply instantiate a new QueueSimulation. Here goes:

 class QueueSimulation
 {
     public static void main(String[] args) {
        for ( int test = 0; test < 3; test ++ ) {
           QueueSimulation sim = new QueueSimulation();
           sim.simulate();
           sim.report();
        }
     }


     Queue<Customer> q = new LinkedList<Customer>();
     int numServed = 0;
     ...
     int totalProcessingTime = 0;

     public void simulate() {
         for ( int i = 0; i < 1000 ) {
             ....
         }
     }

     public void report() {
         System.out.println( ....
         ...           
     }
 }