What is a queue in Java ? Explained with Examples

Looking to know more about the queue in Java? We will be discussing what is a queue in Java and various operations with some examples and how queues are implemented in the Java programming language. Before and further delay, let’s learn.

If you come from a programming background then most probably you might be knowing about queues. Well, if not, then don’t worry, we will cover everything for you.

What is a queue in Java?

In computer programming, there is a very important concept of data structures. This is very useful to solve a lot of real-world problems through computer programming.

The queue is one such data structure that is used to organize data and in the form of arrays, and by traversing those arrays in a fixed order, you can organize and maintain your data.

To understand queues let us take a very common example. Suppose you are standing at a railway ticket booking counter.

Now if you arrive early then you are the first person to get a ticket. So, when you get your ticket you move away and the person behind you comes forward. This is how a queue works.

In computer programming, a queue is implemented in the form of FIFO, i.e first in the first out manner just as we saw in the ticket booking example. Similarly, we implement data in the form of arrays, by using the same FIFO manner.

This concept is the same for any programming language, but the way of the implementation and syntax may differ a little. Here we will see how we can implement a queue using Java programming language.

Also check :   Best class to java decompilers : Try online or download free

How to create a queue?

A queue is basically a structure of some particular size that has some limitations or boundaries. So, to create a queue we first need to create an array and declare two variables name front and rear.

class Queue_creation {

int front;

Int rear;

Int queue_size;

int capacity_queue;

int array[];

public Queue(int capacity_queue)

{

this.capacity_queue = capacity_queue;

front = this.queue_size = 0;

rear = capacity_queue - 1;

array = new int[this.capacity_queue];

}}

The front and the rear are the two integer variables that hold the position of the data to be inserted or deleted from the queue.

With the help of these two variables, the data is entered properly without any deadlock situation or any data loss.

So, initially, we assign the value of the front and the size variable as 0. The value of the rear variable points to the last index of the queue.

In simple ways, a queue is implemented in the form of an array or linked list where each block of the array represents a space in which the data will be stored. Since the data is stored in the form of an array that follows the FIFO pattern, we can also perform some operations on it.

There are a number of operations that are performed in a queue, which we will be discussing in a lot more detail.

The following are the basic operations that are most important for a queue.

1. Isempty

The isempty operation is basically a function that is used to check that if the queue is empty or not. This is done because, when we want to enter data in the queue, then we need to ensure that there is some space in the queue where the data can be added. It is a boolean function, which can be created using the following lines of code.

boolean isEmpty(Queue_creation queue)

{

return (queue.queue_size == 0);

}

2. Isfull

Similar to the isempty operation we have the isfull function. This function ensures that if the queue is full, then no other data can be inserted in the queue. The following code is used to create a boolean function that can be used to check whether a queue is full or not.

boolean isFull(Queue_creation queue)

{

return (queue.queue_size == queue.capacity_queue);

}

If the queue size is equal to the capacity which means that the queue is full and no element can be added further.

Also check :   Java Enum 101 : Explained with easy examples

3. Enqueue

The enqueue operation is important to fill data in a queue. When the queue is empty i.e if a block of the array (queue) is empty then we can enter any data using the enqueue operation.

Once the size of the queue is filled with data we cannot enter further. The following code is used to enter data in a queue and perform the enqueue operation.

Enqueue operation can be done by using the following code block:

void enqueue(int data)

{

if (isFull(this))

return;

this.rear = (this.rear + 1)

% this.capacity_queue;

this.array[this.rear] = data;

this.queue_size = this.queue_size + 1;

System.out.println(data);

}

Here the first thing we check is if the queue is full or not. This is because if the queue is full then we cannot enqueue any other element. So, if the queue is not empty then we first assign the new value to the rear variable. Then we enter the element at the current position to the index where the rear variable is indicating.

4. Dequeue

Now that we have entered data in the queue, we can also remove the data using the dequeue operation. As we know that a queue follows the FIFO pattern, therefore, the data which is entered first can be dequeued first. The following code will help you to perform the dequeue operation on the queue.

int dequeue()

{

if (isEmpty(this))

return Integer.MIN_VALUE;

int data = this.array[this.front];

this.front = (this.front + 1)

% this.capacity_queue;

this.queue_size = this.queue_size - 1;

return data;

}

In this operation, we first check where the queue is empty or not, because if there is no element in the queue then we cannot remove anything. So, when the queue is not empty we remove the element on the current value of front.

public class queue_operations {

public static void main(String[] args)

{

Queue_creation queue = new Queue(1000);

queue.enqueue(300);

queue.enqueue(500);

queue.enqueue(600);

queue.enqueue(700);

System.out.println(queue.dequeue());

}}

Finally, we call the functions that we have created and pass the respective parameters, so here we have first enqueued 4 elements in our queue. And then we have dequeued the queue for one time which means that the element entered first is now removed. Following is the output of this code.

300

500

600

700

300

Conclusion on queue in Java

We hope that we have solved almost all your queries regarding queues and the implementation of queues in Java. For any other doubt, drop a comment below and we will surely try our best to solve it.

Also check :   Best class to java decompilers : Try online or download free

Get occasional tutorials & guides in your inbox. No spam ever.


Buy Me A Coffee

Leave a Comment