A queue is a special type of data structure that works on the First in First out principle. The elements inserted first are removed first. Stacks have one open end while the queue has two open ends. From one end always used to insert elements and from another end always used to remove elements.

Recommended: Stack Implementation in Java using an Array
Real Time Applications
There are plenty of real world applications where the queue is largely used.
For example, When you press a key each time from your keyboard to write a word. These keywords will get into the queue as a sequence and they display on the screen as to how they were entered.
A message queue is a concept used to communicate between processes. When a sender sends a message to a recipient if the recipient does not receive the message maybe because it is busy with some process or the receiver is offline, the message instead of dropping off, wait in a certain kind of queue when the receiver is ready then the message is removed from the queue.
In the Operating system, processes are scheduled based on the queue and execute accordingly.
Various Operation in Queue
Enqueue: Adds an element to the queue. if the queue is full then it is said to be overflow.
Dequeue: Removes an element from the queue. if the queue is empty then it is said to be underflow. the elements are removed in which they are inserted.
Front: Returns the front element of the queue
Rear: Returns the last element of the queue.
Queue data structure implementation
//queue implementation using array
public class Queue {
int capacity;
int front, rear, size;
int array[];
//Initialize instance variables
public Queue(int capacity) {
this.capacity = capacity;
this.front = this.size = 0;
this.rear = this.capacity - 1;
array = new int[capacity];
}
//check the queue is full
boolean isFull(Queue queue) {
//size of the queue and queue capacity are equal
// than queue is full
return (queue.size == queue.capacity);
}
//empty queue check
boolean isEmpty(Queue queue) {
//empty queue size is zero
return (queue.size == 0);
}
//adding element to queue
public void enqueue(int item) {
//checking queue is full
if(isFull(this)) {
System.out.println("Queue is full");
}
//rear modulo capacity returns reminder
//which will be the index of the array and
//where item will be added
rear = (rear + 1) % capacity;
array[rear] = item;
//increasing size
size = size + 1;
System.out.println(item + " is added to queue");
}
//deleting element from the queue
public int dequeue() {
//checking the empty queue and return integer negative value
if(isEmpty(this)) {
return Integer.MIN_VALUE;
}
//size is the front value which is the index of the array.
// it fetch the front element of the queue
int item = array[front];
//increase the front value to get next queued element in queue
//modulo return reminder and front value will be pointing to next value
front = (front + 1) % capacity;
//decrease the size
size = size - 1;
return item;
}
//get front value
int front() {
if(isFull(this)) {
return Integer.MIN_VALUE;
}
//return front index value as front
return array[front];
}
//get rear value
int rear() {
if(this.isEmpty(this)) {
return Integer.MIN_VALUE;
}
//return rear index value as rear
return array[rear];
}
//driver class
public static void main(String[] args) {
Queue queue = new Queue(10);
queue.enqueue(10);
queue.enqueue(20);
queue.enqueue(30);
System.out.println(queue.dequeue() + " removed from the queue");
System.out.println("The front is " + queue.front());
System.out.println("The rear is " + queue.rear());
}
}
output
10 is added to queue
20 is added to queue
30 is added to queue
10 removed from the queue
The front is 20
The rear is 30
Please leave a comment, if you want anything to be corrected or any suggestion on the topic.
Recommended: Stack Implementation in Java using an Array