In Java In the real world, you will often be tasked with understanding and improving another person’s inelegant, hard-to-understand code. This project provides practice for that type of work. The given program, shown below, implements a circular-array queue. A queue is a British term for a line of people waiting to be served. A queue can also refer to any line of items where the item at the front of the queue is served next, and new items are added at the rear of the queue. Informationtransmission systems, like the Internet, have lots of queues, where messages in transit are temporarily stalled at some intermediate system node, waiting to get into the next available time slot on the next leg of their journey. A queue’s length is the total number of people or items currently waiting. When the next item is served, that shortens the queue by one. When another person arrives, that lengthens the queue by one. A queue’s capacity is the maximum number of items that can fit in the line at one time. If a queue is full, its length equals its capacity, and all new arrivals are rejected. The simplest way to implement a queue is with an array and two pointers, a front pointer, which contains the index of the element at the front of the queue, and a rear pointer, which contains the index of the element that is one position past the rear of the queue. When the server calls “next,” the front person gets service, and then the front pointer increments. Each new arrival increments the rear pointer. As time passes, both pointers move to higher values. Does this mean that the array’s length must keep increasing forever? No. Whenever either pointer increments to a value equal to the array’s length (thereby making it one greater than the array’s maximum index), you reassign the pointer to index 0. This effectively connects the end of the array to its beginning and makes it circular. The following CircularQueue class is functionally correct, but inelegant in the three places marked “inelegant.” In this lab, you are to improve the inelegant code, and in the next homework (check Moodle), you will implement a driver class that fully tests your CircularQueue class. So Today, you should provide a new CircularQueue class where the original CircularQueue class’s conditional operators, embedded assignments, and embedded increment operators are replaced within the isFull, remove, and showQueue methods. Hints: You should replace isFull’s code with more compact code. You should replace remove’s code and showQueue’s code with lengthier, but more understandable code. /************************************************************* * CircularQueue.java * Dean & Dean * * This class implements a queue with a circular array. *************************************************************/ public class CircularQueue {  private String[] queue; // array that implements a circular queue  private int length = 0; // number of filled elements  private int capacity; // size of array  private int front = 0; // index of first item in queue  private int rear = 0; // one past the index of the last item  //**********************************************************  // Instantiate the queue's array with the given capacity.  public CircularQueue(int capacity)  {  queue = new String[capacity];  this.capacity = capacity;  } // end constructor  //**********************************************************  public boolean isEmpty()  {  return length == 0;  } // end isEmpty //**********************************************************  public boolean isFull()  {  return length==capacity ? true : false;  } // end isFull  //**********************************************************  public int length()  {  return length;  } // end length  //********************************************************** // Add a value to the rear of the queue by using the rear's  // current position and then incrementing rear.  public boolean add(String name)  {  if (isFull())  {  return false;  }  else  {  queue[rear++] = name;  rear %= capacity; // if rear gets too big, assign it to 0  length++;  return true;  }  } // end add  //**********************************************************  // Remove the value at the front of the queue and then increment  // front.  public String remove()  {  if (isEmpty())  {  return null;  }  else  {  length--;  return queue[(front = ++front % capacity) == 0 ?  capacity-1 : front-1];  }  } // end remove  //**********************************************************  // Display the queue's contents in front-to-rear order.  public void showQueue()  {  int current; // used for walking through the queue  current = front;  if (!isEmpty())  {  do  {  System.out.println(queue[current]);  } while ((current = ++current % capacity) != rear);  }  } // end showQueue } // end CircularQueue class