Rozhraní Queue je přítomno v java.util balíček a prodlužuje Rozhraní sběru se používá k uchování prvků, které mají být zpracovány, v pořadí FIFO (First In First Out). Jedná se o uspořádaný seznam objektů, jehož použití je omezeno na vkládání prvků na konec seznamu a mazání prvků ze začátku seznamu (tj. FIFO nebo princip First-In-First-Out.
Protože se jedná o rozhraní, fronta potřebuje konkrétní třídu pro deklaraci a nejběžnější třídy jsou PriorityQueue a Spojový seznam v Javě. Všimněte si, že žádná z těchto implementací není bezpečná pro vlákna. PriorityBlockingQueue je jednou z alternativních implementací, pokud je potřeba implementace bezpečná pro vlákna.
Prohlášení: Rozhraní fronty je deklarováno jako:
public interface Queue extends Collection>
Vytváření objektů fronty: Od té doby Fronta je rozhraní , nelze vytvořit objekty typu fronta. K vytvoření objektu vždy potřebujeme třídu, která tento seznam rozšiřuje. A také po zavedení Generika v Javě 1.5 je možné omezit typ objektu, který lze uložit do fronty. Tuto typově bezpečnou frontu lze definovat jako:
// Obj is the type of the object to be stored in Queue Queue queue = new PriorityQueue ();>
V Javě je rozhraní Queue podtypem rozhraní Collection a představuje kolekci prvků v určitém pořadí. Dodržuje princip první dovnitř, první ven (FIFO), což znamená, že prvky jsou načteny v pořadí, v jakém byly přidány do fronty.
Rozhraní fronty poskytuje několik metod pro přidávání, odebírání a kontrolu prvků ve frontě. Zde jsou některé z nejčastěji používaných metod:
add(element): Přidá prvek do zadní části fronty. Pokud je fronta plná, vyvolá výjimku.
offer(element): Přidá prvek do zadní části fronty. Pokud je fronta plná, vrátí hodnotu false.
remove(): Odebere a vrátí prvek na začátku fronty. Pokud je fronta prázdná, vyvolá výjimku.
poll(): Odebere a vrátí prvek na začátku fronty. Pokud je fronta prázdná, vrátí hodnotu null.
element(): Vrátí prvek na začátku fronty, aniž by jej odstranil. Pokud je fronta prázdná, vyvolá výjimku.
peek(): Vrátí prvek na začátek fronty, aniž by jej odstranil. Pokud je fronta prázdná, vrátí hodnotu null.
Rozhraní Queue je implementováno několika třídami v Javě, včetně LinkedList, ArrayDeque a PriorityQueue. Každá z těchto tříd poskytuje různé implementace rozhraní fronty s různými výkonnostními charakteristikami a funkcemi.
Celkově je rozhraní Queue užitečným nástrojem pro správu kolekcí prvků v určitém pořadí a je široce používáno v mnoha různých aplikacích a odvětvích.
Příklad:
Jáva
dijkstra
import> java.util.LinkedList;> import> java.util.Queue;> public> class> QueueExample {> >public> static> void> main(String[] args) {> >Queue queue =>new> LinkedList();> >// add elements to the queue> >queue.add(>'apple'>);> >queue.add(>'banana'>);> >queue.add(>'cherry'>);> >// print the queue> >System.out.println(>'Queue: '> + queue);> >// remove the element at the front of the queue> >String front = queue.remove();> >System.out.println(>'Removed element: '> + front);> >// print the updated queue> >System.out.println(>'Queue after removal: '> + queue);> >// add another element to the queue> >queue.add(>'date'>);> >// peek at the element at the front of the queue> >String peeked = queue.peek();> >System.out.println(>'Peeked element: '> + peeked);> >// print the updated queue> >System.out.println(>'Queue after peek: '> + queue);> >}> }> |
>
>Výstup
Queue: [apple, banana, cherry] Removed element: apple Queue after removal: [banana, cherry] Peeked element: banana Queue after peek: [banana, cherry, date]>
Příklad: Fronta
Jáva
// Java program to demonstrate a Queue> import> java.util.LinkedList;> import> java.util.Queue;> public> class> QueueExample {> >public> static> void> main(String[] args)> >{> >Queue q> >=>new> LinkedList();> >// Adds elements {0, 1, 2, 3, 4} to> >// the queue> >for> (>int> i =>0>; i <>5>; i++)> >q.add(i);> >// Display contents of the queue.> >System.out.println(>'Elements of queue '> >+ q);> >// To remove the head of queue.> >int> removedele = q.remove();> >System.out.println(>'removed element-'> >+ removedele);> >System.out.println(q);> >// To view the head of queue> >int> head = q.peek();> >System.out.println(>'head of queue-'> >+ head);> >// Rest all methods of collection> >// interface like size and contains> >// can be used with this> >// implementation.> >int> size = q.size();> >System.out.println(>'Size of queue-'> >+ size);> >}> }> |
>
>Výstup
Elements of queue [0, 1, 2, 3, 4] removed element-0 [1, 2, 3, 4] head of queue-1 Size of queue-4>
Operace na rozhraní fronty
Podívejme se, jak provést několik často používaných operací ve frontě pomocí Třída prioritní fronty .
1. Přidání prvků: Abychom mohli přidat prvek do fronty, můžeme použít metoda add(). . Objednávka vložení není zachována v PriorityQueue. Prvky jsou uloženy na základě pořadí priority, které je ve výchozím nastavení vzestupné.
Příklad
Jáva
linux přejmenovat složku
// Java program to add elements> // to a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >System.out.println(pq);> >}> }> |
>
>Výstup
[For, Geeks, Geeks]>
2. Odebrání prvků: Abychom odstranili prvek z fronty, můžeme použít metoda remove(). Pokud existuje více takových objektů, pak se první výskyt objektu odstraní. Kromě toho se k odstranění hlavy a jejímu vrácení používá také metoda poll().
Příklad
Jáva
// Java program to remove elements> // from a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >System.out.println(>'Initial Queue '> + pq);> >pq.remove(>'Geeks'>);> >System.out.println(>'After Remove '> + pq);> >System.out.println(>'Poll Method '> + pq.poll());> >System.out.println(>'Final Queue '> + pq);> >}> }> |
>
>Výstup
Initial Queue [For, Geeks, Geeks] After Remove [For, Geeks] Poll Method For Final Queue [Geeks]>
3. Iterace fronty: Existuje několik způsobů, jak procházet frontou. Nejznámějším způsobem je převod fronty na pole a procházení pomocí cyklu for. Fronta má však také vestavěný iterátor, který lze použít k iteraci frontou.
Příklad
Jáva
// Java program to iterate elements> // to a Queue> import> java.util.*;> public> class> GFG {> >public> static> void> main(String args[])> >{> >Queue pq =>new> PriorityQueue();> >pq.add(>'Geeks'>);> >pq.add(>'For'>);> >pq.add(>'Geeks'>);> >Iterator iterator = pq.iterator();> >while> (iterator.hasNext()) {> >System.out.print(iterator.next() +>);> >}> >}> }> |
>
>Výstup
For Geeks Geeks>
Vlastnosti fronty: Následují charakteristiky fronty:
- Fronta se používá k vkládání prvků na konec fronty a odebírá se ze začátku fronty. Vychází z konceptu FIFO.
- Java Queue podporuje všechny metody rozhraní kolekce včetně vkládání, mazání atd.
- Spojový seznam , ArrayBlockingQueue a PriorityQueue jsou nejčastěji používané implementace.
- Pokud je na BlockingQueues provedena jakákoli operace null, je vyvolána výjimka NullPointerException.
- Fronty, které jsou dostupné v balíčku java.util, jsou neomezené fronty.
- Fronty, které jsou dostupné v balíčku java.util.concurrent, jsou ohraničené fronty.
- Všechny fronty kromě Deques podporují vkládání a odebírání na konci a na konci fronty. Vkládání a vyjímání nosného prvku Deques na obou koncích.
Třídy, které implementují rozhraní fronty:
1. PriorityQueue: Třída PriorityQueue, která je implementována v rámci kolekce, nám poskytuje způsob, jak zpracovat objekty na základě priority. Je známo, že fronta se řídí algoritmem First-In-First-Out, ale někdy je potřeba zpracovat prvky fronty podle priority, tehdy přichází do hry PriorityQueue. Podívejme se, jak pomocí této třídy vytvořit objekt fronty.
Příklad
Jáva
java system.out.println
// Java program to demonstrate the> // creation of queue object using the> // PriorityQueue class> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty priority queue> >Queue pQueue> >=>new> PriorityQueue();> >// Adding items to the pQueue> >// using add()> >pQueue.add(>10>);> >pQueue.add(>20>);> >pQueue.add(>15>);> >// Printing the top element of> >// the PriorityQueue> >System.out.println(pQueue.peek());> >// Printing the top element and removing it> >// from the PriorityQueue container> >System.out.println(pQueue.poll());> >// Printing the top element again> >System.out.println(pQueue.peek());> >}> }> |
>
>Výstup
10 10 15>
2. Spojový seznam: LinkedList je třída, která je implementována v rámci kolekce, která neodmyslitelně implementuje Příklad
Jáva
// Java program to demonstrate the> // creation of queue object using the> // LinkedList class> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty LinkedList> >Queue ll> >=>new> LinkedList();> >// Adding items to the ll> >// using add()> >ll.add(>10>);> >ll.add(>20>);> >ll.add(>15>);> >// Printing the top element of> >// the LinkedList> >System.out.println(ll.peek());> >// Printing the top element and removing it> >// from the LinkedList container> >System.out.println(ll.poll());> >// Printing the top element again> >System.out.println(ll.peek());> >}> }> |
>
>Výstup
10 10 20>
3. PriorityBlockingQueue: Je třeba poznamenat, že obě implementace, PriorityQueue a LinkedList, nejsou bezpečné pro vlákna. PriorityBlockingQueue je jednou z alternativních implementací, pokud je potřeba implementace bezpečná pro vlákna. PriorityBlockingQueue je neomezená blokovací fronta, která používá stejná pravidla řazení jako třída PriorityQueue a zásoby blokující operace získávání.
Vzhledem k tomu, že je neomezený, přidání prvků může někdy selhat kvůli vyčerpání zdrojů, což má za následek OutOfMemoryError . Podívejme se, jak pomocí této třídy vytvořit objekt fronty.
Příklad
Jáva
// Java program to demonstrate the> // creation of queue object using the> // PriorityBlockingQueue class> import> java.util.concurrent.PriorityBlockingQueue;> import> java.util.*;> class> GfG {> >public> static> void> main(String args[])> >{> >// Creating empty priority> >// blocking queue> >Queue pbq> >=>new> PriorityBlockingQueue();> >// Adding items to the pbq> >// using add()> >pbq.add(>10>);> >pbq.add(>20>);> >pbq.add(>15>);> >// Printing the top element of> >// the PriorityBlockingQueue> >System.out.println(pbq.peek());> >// Printing the top element and> >// removing it from the> >// PriorityBlockingQueue> >System.out.println(pbq.poll());> >// Printing the top element again> >System.out.println(pbq.peek());> >}> }> |
>
>Výstup
10 10 15>
Metody rozhraní fronty
Rozhraní fronty dědí všechny metody přítomné v rozhraní sbírek při implementaci následujících metod:
| Metoda | Popis |
|---|---|
| add(int index, prvek) | Tato metoda se používá k přidání prvku do určitého indexu ve frontě. Když je předán jeden parametr, jednoduše přidá prvek na konec fronty. |
| addAll(int index, kolekce kolekce) | Tato metoda se používá k přidání všech prvků v dané kolekci do fronty. Když je předán jeden parametr, přidá všechny prvky dané kolekce na konec fronty. |
| velikost() | Tato metoda se používá k vrácení velikosti fronty. |
| Průhledná() | Tato metoda se používá k odstranění všech prvků ve frontě. Odkaz na vytvořenou frontu je však stále uložen. |
| odstranit() | Tato metoda se používá k odstranění prvku z přední části fronty. |
| odstranit (int index) | Tato metoda odebere prvek ze zadaného indexu. Následující prvky (pokud existují) posune doleva a sníží jejich indexy o 1. |
| odstranit (prvek) | Tato metoda se používá k odstranění a vrácení prvního výskytu daného prvku ve frontě. |
| get(int index) | Tato metoda vrací prvky na zadaném indexu. |
| set(int index, prvek) | Tato metoda nahradí prvky na daném indexu novým prvkem. Tato funkce vrací prvek, který byl právě nahrazen novým prvkem. |
| indexOf(prvek) | Tato metoda vrací první výskyt daného prvku resp -1 pokud prvek není přítomen ve frontě. |
| lastIndexOf(prvek) | Tato metoda vrací poslední výskyt daného prvku resp -1 pokud prvek není přítomen ve frontě. |
| rovná se (prvek) | Tato metoda slouží k porovnání rovnosti daného prvku s prvky fronty. |
| hashCode() | Tato metoda se používá k vrácení hodnoty hashcode dané fronty. |
| je prázdný() | Tato metoda se používá ke kontrole, zda je fronta prázdná nebo ne. Vrací hodnotu true, pokud je fronta prázdná, v opačném případě vrací hodnotu false. |
| obsahuje (prvek) | Tato metoda se používá ke kontrole, zda fronta obsahuje daný prvek či nikoliv. Pokud fronta obsahuje prvek, vrátí hodnotu true. |
| obsahuje vše (kolekce kolekce) | Tato metoda se používá ke kontrole, zda fronta obsahuje celou kolekci prvků. |
| řazení (komparátor) | Tato metoda se používá k řazení prvků fronty na základě daného srovnávač . |
| booleovské přidání (objekt) | Tato metoda se používá k vložení zadaného prvku do fronty a po úspěchu vrátí hodnotu true. |
| booleovská nabídka (objekt) | Tato metoda se používá k vložení zadaného prvku do fronty. |
| Object poll() | Tato metoda se používá k načtení a odstranění hlavy fronty nebo vrátí hodnotu null, pokud je fronta prázdná. |
| Object element() | Tato metoda se používá k načtení, ale neodstraní hlavu fronty. |
| Pohled na objekt () | Tato metoda se používá k načtení, ale neodstraní hlavičku této fronty, nebo vrátí hodnotu null, pokud je tato fronta prázdná. |
Výhody použití rozhraní Queue v Javě:
Uchování objednávky : Rozhraní Queue poskytuje způsob, jak ukládat a načítat prvky v určitém pořadí podle principu FIFO (first-in, first-out).
Flexibilita : Rozhraní Queue je podtypem rozhraní Collection, což znamená, že jej lze použít s mnoha různými datovými strukturami a algoritmy v závislosti na požadavcích aplikace.
Vlákno – bezpečnost : Některé implementace rozhraní Queue, jako je třída java.util.concurrent.ConcurrentLinkedQueue, jsou bezpečné pro vlákna, což znamená, že k nim může přistupovat více vláken současně, aniž by docházelo ke konfliktům.
Výkon : Rozhraní Queue poskytuje efektivní implementace pro přidávání, odebírání a kontrolu prvků, což z něj činí užitečný nástroj pro správu kolekcí prvků v aplikacích kritických pro výkon.
Verilog vždy
Nevýhody použití rozhraní Queue v Javě:
Omezená funkčnost: Rozhraní Queue je navrženo speciálně pro správu kolekcí prvků v určitém pořadí, což znamená, že nemusí být vhodné pro složitější datové struktury nebo algoritmy.
Omezení velikosti: Některé implementace rozhraní Queue, jako je třída ArrayDeque, mají pevnou velikost, což znamená, že nemohou přesáhnout určitý počet prvků.
Využití paměti: V závislosti na implementaci může rozhraní Queue vyžadovat více paměti než jiné datové struktury, zejména pokud potřebuje uložit další informace o pořadí prvků.
Složitost : Pro začínající programátory může být obtížné používat a pochopit rozhraní Queue, zvláště pokud nejsou obeznámeni s principy datových struktur a algoritmů.