Fronta je další druh lineární datové struktury, která se používá k ukládání prvků stejně jako jakákoli jiná datová struktura, ale určitým způsobem. Zjednodušeně lze říci, že fronta je typ datové struktury v programovacím jazyce Java, která ukládá prvky stejného druhu. Komponenty ve frontě jsou uloženy v chování FIFO (First In, First Out). Kolekce fronty má dva konce, tj. přední a zadní. Fronta má dva konce, přední a zadní.

Následující obrázek dokonale popisuje vlastnost FIFO (First In, First Out) fronty Java.

Jak je vysvětleno na předchozím obrázku, můžeme vidět, že fronta je lineární datová struktura se dvěma terminály, tj. začátkem (přední) a koncem (zadní). Komponenty jsou přidávány do fronty ze zadního konce fronty a komponenty jsou extrahovány z předního konce fronty.

Fronta je rozhraní v Jáva který patří do balíčku Java.util . Rozšiřuje také rozhraní kolekce .

Obecná reprezentace rozhraní Java Queue je uvedena níže:

 public interface Queue extends Collection 

Jak jsme diskutovali výše, že fronta je rozhraní, můžeme také říci, že frontu nelze vytvořit instanci, protože rozhraní nelze vytvořit. Pokud chce uživatel implementovat funkcionalitu rozhraní Queue v Javě, pak je povinný mít nějaké solidní třídy, které implementují rozhraní Queue.

V programovacím jazyce Java existují dvě různé třídy, které se používají k implementaci rozhraní Queue. Tyto třídy jsou:

java int v řetězci

• Spojový seznam
• PriorityQueue

Charakteristika Java Queue

Java Queue lze považovat za jednu z nejdůležitějších datových struktur ve světě programování. Java Queue je atraktivní svými vlastnostmi. Významné vlastnosti datové struktury Java Queue jsou uvedeny následovně:

• Java Queue se řídí způsobem FIFO (First In, First Out). Označuje, že prvky jsou zařazeny do fronty na konci a odstraněny zepředu.
• Rozhraní Java Queue poskytuje všechna pravidla a procesy rozhraní kolekce, jako je zahrnutí, mazání atd.
• Existují dvě různé třídy, které se používají k implementaci rozhraní Queue. Tyto třídy jsou LinkedList a PriorityQueue.
• Kromě těchto dvou existuje třída, která je, Array Blocking Queue, která se používá k implementaci rozhraní Queue.
• Existují dva typy front, Neohraničené fronty a Ohraničené fronty. Fronty, které jsou součástí balíčku java.util, jsou známé jako neohraničené fronty a ohraničené fronty jsou fronty, které jsou přítomné v balíčku java.util.concurrent.
• Deque nebo (dvojitá fronta) je také typ fronty, která nese zahrnutí a odstranění prvků z obou konců.
• Deque je také považováno za bezpečné pro vlákna.
• Blokovací fronty jsou také jedním z typů front, které jsou také bezpečné pro vlákna. Blokovací fronty se používají k implementaci dotazů výrobce-spotřebitel.
• Blokovací fronty nepodporují prvky null. Pokud se ve frontách blokování vyzkouší nějaká práce podobná hodnotám null, vyvolá se také výjimka NullPointerException.

Implementace Queue

Třídy používané při implementaci Queue

Třídy, které se používají k implementaci funkcí fronty, jsou uvedeny následovně:

armstrongovo číslo

• ArrayDeque
• Spojový seznam
• PriorityQueue

Rozhraní použitá při implementaci Queue

Rozhraní Java se také používají při implementaci fronty Java. Rozhraní, která se používají k implementaci funkcí fronty, jsou uvedena následovně:

• O čem
• Blokovací fronta
• Blokování Deque

Java Queue Class Methods

Ve frontě Java existuje mnoho metod, které se používají velmi běžně. Rozhraní fronty podporuje různé metody, jako je vkládání, mazání, prohlížení atd. Některé operace fronty Java vyvolávají výjimku, zatímco některé z těchto operací vracejí určitou hodnotu, když je program dokončen.

Poznámka - V Java SE 8 nejsou provedeny žádné změny v kolekci front Java. Tyto metody, které jsou definovány níže, jsou dále připravovány v následujících verzích programovacího jazyka Java. Například Java SE 9.

Různé metody Java Queue jsou definovány níže:

Implementace Java Queue Array

Implementace fronty není tak přímočará jako implementace zásobníku.

Abychom implementovali frontu pomocí Arrays, nejprve deklarujeme pole, které obsahuje n počet prvků.

Poté definujeme následující operace, které mají být provedeny v této frontě.

1) Zařadit do fronty: Operace pro vložení prvku do fronty je Enqueue (funkce fronta Enqueue v programu). Pro vložení prvku na zadní konec musíme nejprve zkontrolovat, zda je fronta plná. Pokud je plný, nemůžeme prvek vložit. Pokud zadní

2) Ocas: Operace pro odstranění prvku z fronty je Dequeue (funkce fronta Dequeue v programu). Nejprve zkontrolujeme, zda je fronta prázdná. Aby operace vyřazení z fronty fungovala, musí být ve frontě alespoň jeden prvek.

3) Přední strana: Tato metoda vrací začátek fronty.

4) Displej: Tato metoda prochází frontou a zobrazuje prvky fronty.

java valueof enum

Program Java Queue

Následující program Java demonstruje implementaci Queue.

QueueArrayImplementation.java

 class Queue { private static int front, rear, capacity; private static int queue[]; Queue(int size) { front = rear = 0; capacity = size; queue = new int[capacity]; } // insert an element into the queue static void queueEnqueue(int item) { // check if the queue is full if (capacity == rear) { System.out.printf('
Queue is full
'); return; } // insert element at the rear else { queue[rear] = item; rear++; } return; } //remove an element from the queue static void queueDequeue() { // check if queue is empty if (front == rear) { System.out.printf('
Queue is empty
&apos;); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i <rear 0 4 - 1; i++) { queue[i]="queue[i" + 1]; } set queue[rear] to if (rear < capacity) decrement rear rear--; return; print queue elements static void queuedisplay() int i; (front="=" rear) system.out.printf('queue is empty
'); traverse front and for (i="front;" i rear; system.out.printf(' %d , ', queue[i]); of queuefront() system.out.printf('
front element the queue: %d', queue[front]); public class queuearrayimplementation main(string[] args) create a capacity q="new" queue(4); system.out.println('initial queue:'); q.queuedisplay(); inserting in q.queueenqueue(10); q.queueenqueue(30); q.queueenqueue(50); q.queueenqueue(70); system.out.println('queue after enqueue operation:'); q.queuefront(); insert q.queueenqueue(90); q.queuedequeue(); system.out.printf('
queue two dequeue operations:'); pre> <p> <strong>Output:</strong> </p> <pre> Initial Queue: Queue is Empty Queue after Enqueue Operation: 10 , 30 , 50 , 70 , Front Element of the queue: 10 Queue is full 10 , 30 , 50 , 70 , Queue after two dequeue operations: 50 , 70 , Front Element of the queue: 50 </pre> <h2>Java Queue Linked List Implementation</h2> <p>As we have implemented the Queue data structure using Arrays in the above program, we can also implement the Queue using Linked List.</p> <p>We will implement the same methods enqueue, dequeue, front, and display in this program. The difference is that we will be using the Linked List data structure instead of Array.</p> <p>The below program demonstrates the Linked List implementation of Queue in Java.</p> <p> <strong>QueueLLImplementation.java</strong> </p> <pre> class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front &amp; rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println(&apos;Element &apos; + data+ &apos; removed from the queue&apos;); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println(&apos;Element &apos; + data+ &apos; added to the queue&apos;); } //print front and rear of the queue public void print_frontRear() { System.out.println(&apos;Front of the queue:&apos; + front.data + &apos; Rear of the queue:&apos; + rear.data); } } class QueueLLImplementation{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } } </pre> <p> <strong>Output:</strong> </p> <pre> Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9 </pre> <hr></rear>

Implementace propojeného seznamu Java Queue

Protože jsme ve výše uvedeném programu implementovali datovou strukturu Queue pomocí Arrays, můžeme také implementovat Queue pomocí Linked List.

V tomto programu implementujeme stejné metody enqueue, dequeue, front a display. Rozdíl je v tom, že místo Array budeme používat datovou strukturu Linked List.

Níže uvedený program ukazuje implementaci Linked List pro Queue v Javě.

QueueLLImplementation.java

 class LinkedListQueue { private Node front, rear; private int queueSize; // queue size //linked list node private class Node { int data; Node next; } //default constructor - initially front & rear are null; size=0; queue is empty public LinkedListQueue() { front = null; rear = null; queueSize = 0; } //check if the queue is empty public boolean isEmpty() { return (queueSize == 0); } //Remove item from the front of the queue. public int dequeue() { int data = front.data; front = front.next; if (isEmpty()) { rear = null; } queueSize--; System.out.println('Element ' + data+ ' removed from the queue'); return data; } //Add data at the rear of the queue. public void enqueue(int data) { Node oldRear = rear; rear = new Node(); rear.data = data; rear.next = null; if (isEmpty()) { front = rear; } else { oldRear.next = rear; } queueSize++; System.out.println('Element ' + data+ ' added to the queue'); } //print front and rear of the queue public void print_frontRear() { System.out.println('Front of the queue:' + front.data + ' Rear of the queue:' + rear.data); } } class QueueLLImplementation{ public static void main(String a[]){ LinkedListQueue queue = new LinkedListQueue(); queue.enqueue(6); queue.enqueue(3); queue.print_frontRear(); queue.enqueue(12); queue.enqueue(24); queue.dequeue(); queue.dequeue(); queue.enqueue(9); queue.print_frontRear(); } } 

Výstup:

 Element 6 added to the queue Element 3 added to the queue Front of the queue:6 Rear of the queue:3 Element 12 added to the queue Element 24 added to the queue Element 6 removed from the queue Element 3 removed from the queue Element 9 added to the queue Front of the queue:12 Rear of the queue:9