Question

Do in java file Queues are often used to simulate the flow of people, cars, airplanes, transactions, and so on. Write a program that models checkout lines at a supermarket, using the Queue class from the queue.java program (Listing 4.4). Several lines of customers should be displayed; you can use the display, insertſ), and remove() method. You can add a new customer by pressing a key. You'll need to determine how the customer will decide which line to join. The checkers will take random amounts of time to process each customer (presumably depending on how many groceries the customer has). Once checked out, the customer is removed from the line. For simplicity, you can simulate the passing of time by pressing a key. Perhaps every keypress indicates the passage of one minute. Use link List as Data Structure and queue as a main abstract data structure. Listing 4.4 class Queue { private int maxSize; private long[] queArray; private int front; private int rear; private int nItems; //-- // public Queue (int s) constructor maxSize S; queArray - new long(maxSize]; front = 0; rear - -1; nItems = 0; ---- public void insert (long j) item at rear of queue // put if (rear == maxSize-1) deal with wraparound rear - -1; queArray[++rear] j; increment rear and insert nItems:

please explain all the steps. I need it ASAP.

i will give u good ratings.

Answer 1

Here i am providing the code. Hope it helps. please give me a like it helps me a lot.

// Queue.java

public class Queue {

      private int maxSize;

      private long[] queArray;

      private int front;

      private int rear;

      private int nItems;

      // --------------------------------------------------------------

      public Queue(int s) // constructor

      {

            maxSize = s;

            queArray = new long[maxSize];

            front = 0;

            rear = -1;

            nItems = 0;

      }

      // --------------------------------------------------------------

      public void insert(long j) // put item at rear of queue

      {

            if (rear == maxSize - 1) // deal with wraparound

                  rear = -1;

            queArray[++rear] = j; // increment rear and insert

            nItems++; // one more item

      }

      // --------------------------------------------------------------

      public long remove() // take item from front of queue

      {

            long temp = queArray[front++]; // get value and incr front

            if (front == maxSize) // deal with wraparound

                  front = 0;

            nItems--; // one less item

            return temp;

      }

      // --------------------------------------------------------------

      public long peekFront() // peek at front of queue

      {

            return queArray[front];

      }

      // --------------------------------------------------------------

      public boolean isEmpty() // true if queue is empty

      {

            return (nItems == 0);

      }

      // --------------------------------------------------------------

      public boolean isFull() // true if queue is full

      {

            return (nItems == maxSize);

      }

      // --------------------------------------------------------------

      public int size() // number of items in queue

      {

            return nItems;

      }

      // --------------------------------------------------------------

      public void display() // display content of queue

      {

            // System.out.println("Array: " +Arrays.toString(queArray));

//          if (nItems < 1) {

//                System.out.println("Array: " + Arrays.toString(queArray));

//                System.out.println("Queue: ");

//                return;

//          }

//          System.out.println("Array: " + Arrays.toString(queArray));

//          System.out.print("Queue: ");

            int ft = front;

            for (int i = 1; i <= nItems; i++) {

                  System.out.print(queArray[ft] + " ");

                  ft = (ft + 1) % maxSize;

            }

            System.out.println();

      }

} // end class Queue

/**

* This class simulates a Checker at a Store.

* Assumption: No checker will take more than 10 minutes to process a customer.

*/

import java.util.Random;

public class Checker {

      // Instance variables

      private Queue queue;

      private int processingTime; // Processing time for one customer, vary as per

                                                // the customer

      private int startTime; // Time when the current customer arrived at the

                                          // checker

      private Random random;

      /**

      * Constructor

      *

      * @param maxLL

      *            - max line length at the checker

      */

      public Checker(int maxLL) {

            queue = new Queue(maxLL);

            startTime = -1;

            processingTime = -1;

            random = new Random();

      }

      /**

      * Displays the line at this checker

      */

      public void display() {

            queue.display();

      }

      /**

      * Adds a customer to the queue

      *

      * @param time

      *            - time in the store

      * @param customer

      *            - customer

      */

      public void addToLine(int time, long customer) {

            // Add customer to the line

            queue.insert(customer);

           

            // Set time only if this is the first customer

            if (queue.size() == 1)

                  setTime(time);

      }

      /**

      * Returns the waiting time for a new customer. i.e. the time to process the

      * current customer plus the time to process the remaining customers (if

      * any).

      *

      * @param time

      *            - time in the store

      * @return - If line is empty returns 0, if line if full returns -1 else

      *         returns the waiting time for a new customer.

      */

      public int waitingTime(int time) {

            if (queue.isEmpty()) // Check if line is empty

                  return 0;

            else if (queue.isFull()) // Check if line is full

                  return -1;

            else {

                  // Find time elapsed after the current customer arrived at the

                  // checker

                  int timeElapsed = (time - this.startTime);

                  // Find the time remaining to process the current customer

                  int timeForCurrCustomer = this.processingTime - timeElapsed;

                  // If there are more than 1 customer, then to calculate the average

                  // waiting time for a new customer, we have to assume that the

                  // checker

                  // will require the same processing time for the remaining

                  // customers.

                  int timeForRemainingCustomer = ((queue.size() - 1) * this.processingTime);

                  // Return the total wait time

                  return timeForCurrCustomer + timeForRemainingCustomer;

            }

      }

      /**

      * Updates the checker as per the time.

      *

      * @param time

      *            - time in the store

      */

      public void updateLine(int time) {

            // Check if line is not empty

            if (!queue.isEmpty()) {

                  // Find time elapsed after the current customer arrived at the

                  // checker

                  int timeElapsed = (time - this.startTime);

                  // Check if the current customer is billed

                  if (timeElapsed == this.processingTime) {

                        // Remove the customer from the queue

                        queue.remove();

                        // Reset start time and processing time

                        startTime = -1;

                        processingTime = -1;

                        // If there is any other customer in the line, then set the

                        // startTime and processing time for that customer

                        if (!queue.isEmpty())

                              setTime(time);

                  }

            }

      }

      /**

      * Sets the start and processing time as per the store's time

      *

      * @param time

      *            - store time

      */

      private void setTime(int time) {

            startTime = time;

            processingTime = random.nextInt(10) + 1;

      }

}

/**

* This class simulates a store.

*/

public class Store {

      // The array to hold the customer who will be arriving at the checker

      private static long[] customer = { 10, 20, 30, 40, 50, 60, 70 };

      // Instance variables

      private int nCheckers;

      private Checker[] checker;

      private int time; // Time in minutes

      private int customerNum;

      /**

      * Constructor

      *

      * @param nCheckers

      *            - number of checkers in the store

      * @param maxLL

      *            - max line length

      */

      public Store(int nCheckers, int maxLL) {

            this.nCheckers = nCheckers;

            // Init checker array

            this.checker = new Checker[this.nCheckers];

            // Create each checker

            for (int i = 0; i < this.nCheckers; i++)

                  this.checker[i] = new Checker(maxLL);

            // Set start of the time/tick

            this.time = 0;

            // Customer number

            this.customerNum = 0;

      }

      /**

      * Displays all checkers at the store

      */

      public void display() {

            for (int i = 0; i < checker.length; i++) {

                  System.out.print("Checker " + (i + 1) + ": ");

                  checker[i].display();

            }

      }

      /**

      * Increments the time by 1.

      */

      public void masterTick() {

            time += 1;

            // After the time ticks, update all the checkers

            updateChecker();

      }

      /**

      * Updates all the checkers as per the time

      */

      private void updateChecker() {

            for (Checker c : checker)

                  c.updateLine(time);

      }

      /**

      * Simulates the entry of a new customer at one of the checkers.

      */

      public void newCustomer() {

            int minWaitTime = Integer.MAX_VALUE; // Minimum waiting time

            int checkerNum = -1; // The checker number where waiting time will be

                                                // minimum

            // Find the line where waiting time is minimum

            for (int i = 0; i < checker.length; i++) {

                  // Get waiting time at the checker

                  int waitTime = checker[i].waitingTime(time);

                  // If the wait time at checker[i] is less than minWaitTime

                  if (waitTime < minWaitTime) {

                        minWaitTime = waitTime;

                        checkerNum = i;

                  }

            }

            // If checkerNum is -1 that means all the lines are full and the

            // customer will have to wait

            // Check if a checker with minimum wait time is found

            if (checkerNum != -1) {

                  // Add customer to the line

                  checker[checkerNum].addToLine(time, customer[customerNum++]);

            }

      }

      /**

      * Checks whether there is any customer left

      *

      * @return - Returns true if there is a customer left, false otherwise

      */

      public boolean hasNextCustomer() {

            return (customerNum < customer.length);

      }

}

/**

* This class simulates a store.

*/

import java.io.IOException;

import java.util.Scanner;

public class SimApp {

      // Scanner to get user input

      private static Scanner in = new Scanner(System.in);

      /**

      * Gets a character from the user.

      *

      * @return - Returns the character if it is valid (s or t or e), else

      *         returns -1

      */

      private static int getChar() {

            String ans = in.nextLine().trim().toLowerCase();

            // Check if the correct character is entered

            if (ans.equals("s") || ans.equals("t") || ans.equals("e"))

                  return ans.charAt(0);

            else

                  return -1;

      }

      public static void main(String[] args) throws IOException {

            int nCheckers = 3; // number of checkers

            int maxLL = 12; // maximum line length

            Store theStore = new Store(nCheckers, maxLL);

//          while (true) {

            while (theStore.hasNextCustomer()) {

                  System.out.print("Enter first letter of ");

                  System.out.print("show, tick, enter: ");

                  int choice = getChar();

                  switch (choice) {

                  case 's':

                        theStore.display();

                        break;

                  case 't':

                        theStore.masterTick();

                        theStore.display();

                        break;

                  case 'e':

                        theStore.newCustomer();

                        theStore.display();

                        break;

                  default:

                        System.out.print("Invalid entry\n");

                  } // end switch

            } // end while

      } // end main()

}

SAMPLE OUTPUT:

Enter first letter of show, tick, enter: s Checker 1: Checker 2: Checker 3: Enter first letter of show, tick, enter: e Checker 1: 10 Checker 2: Checker 3: Enter first letter of show, tick, enter: t Checker 1: 10 Checker 2: Checker 3: Enter first letter of show, tick, enter: e Checker 1: 10 Checker 2: 20 Checker 3: Enter first letter of show, tick, enter: t Checker 1: Checker 2: 20 Checker 3: Enter first letter of show, tick, enter: t Checker 1: Checker 2: 20 Checker 3: Enter first letter of show, tick, enter: e Checker 1: 30 Checker 2: 20 Checker 3: Enter first letter of show, tick, enter: e Checker 1: 30 Checker 2: 20 Checker 3: 40 Enter first letter of show, tick, enter: Checker 1: 30 50 Checker 2: 20 Checker 3: 40 Enter first letter of show, tick, enter: t e

Checker 1: 50 Checker 2: 20 Checker 3: 40

Please find below a table which traces the above output. You have to run the program in DEBUG mode in eclipse to get the processing time for each customer.

s e t e t t e e e t Action Time at store Checker 1 0 0 1 1 2 3 3 3 3 4 (Customer 10 has been billed and hence moved out of the queue) 50 50 10 2 10 2 10 2 30 1 30 1 30 1 4. 20 20 20 20 20 20 Customer Processing time Checker 2 Customer Processing time Checker 3 Customer Processing time 20 5 5 5 5 5 5 5 40 40 40 3 3 3

Thank you. please upvote.