Implementing Queue Using Array in Java

We can implement queue by using array in Java. The queue is a linear data structure, and the array is one of the simplest data structures. Before implementing a queue using an array, let us know about the queue and its operations, and we also will learn about arrays.

Queue Data Structure

The queue data structure is open at both ends. If we compare the queue with the stack data structure, the stack is opened only at one end. It is one of the linear data structures. This queue is called a linear data structure because the arrangements of the elements or the data we are given follow a linear trend. In the queue data structure, the data is arranged in such a way that the data or element is directly linked to the previous data or element and also the next data or element. It follows First In First Out (FIFO). First in, first out means if the element is added first in the queue, then the same will be get deleted or else, we can it will be removed from the queue.

Not only in the java programming language but also, we can implement queues using arrays in other programming languages also, like C++, Python, C#, Java, in Javascript. We know that the array will have a fixed size, so we can only pass a fixed number of elements into the array. So, because the array is fixed size, an issue will occur in the implementation of the queue when we want to implement a queue using an array. A gap will be created in the queue data structure when an element is added to the queue and deleted from the queue. But we can fill this gap by rearing the elements which are remained, but this process of rearranging is a time-consuming process. So, to overcome this issue, we can use a circular queue which is one of the types of queue data structure. By using this circular queue while implementing the queue using an array, even after reaching the maximum size of the array, we can proceed.

Array

We can define the array as the simplest data structure when compared to others. In this array, we can store data elements which are similar at contiguous locations. The elements which are of the same type only like if we declared the array as int we could not pass characters into the array along with the integers.

Steps for Implementing the Queue Using Array

• First, create an array of some size.
• Take two variables where each variable should represent the "front" of the queue and the "rear" of the queue.
• Initialize those two variables to "zero". The reason is queue is empty at the start, so we do not have any elements in the queue. So, that is the reason we initialize those two variables to zero at the start.
• The rear is the index which indicates whether the elements are stored in the array or not. And the front is the index in the queue, which indicates the first element of the array.

These are the few steps that need to be followed when we are implementing the queue using array not only in a java programming language but also in other programming languages too.

Insertion of the element into the queue, deletion of the element from the queue, display and front are the operations that we can do on a queue-based system.

At the rear end, the insertion of the element is done. So, whenever we want to add an element to the queue, we have to add that particular element to the rear side. This adding of element into the queue is also known as "Enqueue".

At the front end, the deletion of the element is done. So, whenever we want to delete an element from the queue, we have to delete that element from the front end. This is deleting an element from the queue, also known as "Dequeue".

And display operation will display all the elements of the queue.

By the front operation in the queues, we can get the front element from the queue.

ImplementingQueue.java

Public class ImplementingQueue 
{  
  private int maxSize;  
  private int[] queueArray;  
  private int front;  
  private int rear;  
  private int currentCapacity;  
  public ImplementingQueue (int size)  
  {  
    this.maxSize = size;  
    this.queueArray = new int[size];  
    front = 0;  
    rear = -1;  
    currentCapacity = 0;  
  }  
  public void insert(int item)  
  {  
    if(isQueueFull())  
    {  
      System.out.println("Queue data structure is full");  
      return;  
    }  
    if(rear == maxSize - 1)  
{  
      rear = -1;  
    }  
    //Incrementing the rear
    queueArray[++rear] = item;  
    currentCapacity++;  
    System.out.println("Enqueue is done: " + item);  
  }  
  //Dequeue operation
  public int delete()  
  {  
    if(isQueueEmpty())  
    {  
      throw new RuntimeException("Queue is empty");  
    }  
    int temp = queueArray[front++];  
    if(front == maxSize)  
    {  
      front = 0;  
    }  
    currentCapacity--;  
    return temp;
}  
 //peek operation      
  public int peek()  
  {  
    return queueArray[front];  
  }  
  public boolean isQueueFull()  
  {  
    return (maxSize == currentCapacity);  
  }      
  public boolean isQueueEmpty()  
{  
    return (currentCapacity == 0);  
  }  
  public static void main(String[] args)   
  {  
    ImplementingQueue  queue = new ImplementingQueue (10);  
    queue.insert(8);  
    queue.insert(9);  
    System.out.println("Deleted item form the queue: " + queue.delete());  
    System.out.println("Deleted item from the queue: " + queue.delete());  
    queue.insert(10);      
    System.out.println("Deleted item from the queue: " + queue.delete());      
  }  
}  

Output: