java queue queue methods
В този урок ще обсъдим Какво е опашка в Java, Как да я използвам, Пример за опашка на Java, Методи за опашка на Java и Внедряване на интерфейса на опашката:
Опашката е линейна структура от данни или колекция в Java, която съхранява елементи в FIFO (First In, First Out) ред.
Събирането на опашки има два края, т.е.пред и отзад. Елементите се добавят отзад и се отстраняват отпред.
=> Посетете тук, за да видите серията за обучение за Java за всички.
Какво ще научите:
Какво е Java Queue?
Структурата на данните за опашката е представена, както е показано по-долу:
Както е показано на горната диаграма, опашката е структура, имаща две точки, т.е. начало (отпред) и край (отзад). Елементите се вмъкват в опашката отзад и се отстраняват от опашката отпред.
В Java Queue е интерфейс, който е част от пакета java.util. Интерфейсът на опашката разширява интерфейса на Java Collection.
Общата дефиниция на интерфейса на опашката е:
public interface Queue extends CollectionТъй като Queue е интерфейс, той не може да бъде създаден. Имаме нужда от някои конкретни класове, за да реализираме функционалността на интерфейса на опашката. Два класа изпълняват интерфейса на опашката, т.е. LinkedList и PriorityQueue.
Следват някои от основните характеристики на структурата на данните за опашката:
- Опашката следва реда на FIFO (First In, First Out). Това означава, че елементът се вмъква в опашката в края и се отстранява от опашката в началото.
- Интерфейсът на опашката Java предоставя всички методи на интерфейса за събиране, като вмъкване, изтриване и т.н.
- LinkedList и PriorityQueue са класовете, които реализират интерфейса на опашката. ArrayBlockingQueue е още един клас, който реализира интерфейса на Queue.
- Опашките, които са част от пакета java.util, могат да бъдат класифицирани като неограничени опашки, докато тези, които се намират в java.util.едновременният пакет, са ограничени опашки.
- Deque е опашка, която поддържа вмъкване и изтриване от двата края.
- Deque е безопасен за резби.
- BlockingQueues са безопасни за нишки и се използват за изпълнение на проблеми производител-потребител.
- BlockingQueues не позволяват нулеви елементи. Извършва се NullPointerException, ако се опита да се извърши някаква операция, свързана с нулеви стойности.
Как да използвам опашка в Java?
За да използваме опашка в Java, първо трябва да импортираме интерфейса на опашката, както следва:
import java.util.queue; Или
import java.util.*; След като това бъде импортирано, можем да създадем опашка, както е показано по-долу:
Queue str_queue = new LinkedList (); Тъй като Queue е интерфейс, ние използваме клас LinkedList, който реализира интерфейса Queue, за да създадем обект на опашка.
По същия начин можем да създадем опашка с други конкретни класове.
Queue str_pqueue = new PriorityQueue (); Queue int_queue = new ArrayDeque (); Сега, когато обектът на опашката е създаден, можем да инициализираме обекта на опашката, като му предоставим стойностите чрез метода за добавяне, както е показано по-долу.
str_queue.add(“one”); str_queue.add(“two”); str_queue.add(“three”);Пример за Java Queue
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue str_queue = new LinkedList(); //initialize the queue with values str_queue.add('one'); str_queue.add('two'); str_queue.add('three'); str_queue.add('four'); //print the Queue System.out.println('The Queue contents:' + str_queue); } }Изход:
Съдържанието на опашката: (едно, две, три, четири)
Горният пример показва декларирането и инициализирането на обект на опашка. След това просто отпечатваме съдържанието на опашката.
Методи на опашката в Java
В този раздел ще обсъдим методите на API за опашката. Интерфейсът на опашката поддържа различни операции като вмъкване, изтриване, надникване и др. Някои операции предизвикват изключение, докато някои връщат конкретна стойност, когато методът успее или се провали.
Имайте предвид, че няма специфични промени в колекцията Queue в Java 8. Методите по-долу са налични и в по-нови версии на Java като Java 9 и т.н.
Таблицата по-долу обобщава всички тези методи.
| Метод | Прототип на метода | Описание |
|---|---|---|
| размер | размер int () | Връща размера или броя на елементите в опашката. |
| добавете | булево добавяне (E e) | Добавя елемент e към опашката в края (опашката) на опашката, без да нарушава ограниченията за капацитета. Връща true ако успех или IllegalStateException, ако капацитетът е изчерпан. |
| надникнете | E peek() | Връща главата (отпред) на опашката, без да я премахва. |
| елемент | E element() | Извършва същата операция като метода peek (). Изхвърля NoSuchElementException, когато опашката е празна. |
| Премахване | E премахване () | Премахва главата на опашката и я връща. Изхвърля NoSuchElementException, ако опашката е празна. |
| анкета | E poll() | Премахва главата на опашката и я връща. Ако опашката е празна, тя връща null. |
| Оферта | булево предложение (E e) | Поставете новия елемент e в опашката, без да нарушавате ограниченията на капацитета. |
Итерация на елементите на опашката
Можем да преминем през елементите на опашката или чрез цикъла forEach, или с помощта на итератор. Дадената по-долу програма изпълнява и двата подхода за пресичане на опашката.
import java.util.*; public class Main { public static void main(String() args) { //declare a Queue Queue LL_queue = new LinkedList(); //initialize the Queue LL_queue.add('Value-0'); LL_queue.add('Value-1'); LL_queue.add('Value-2'); LL_queue.add('Value-3'); //traverse the Queue using Iterator System.out.println('The Queue elements through iterator:'); Iterator iterator = LL_queue.iterator(); while(iterator.hasNext()){ String element = (String) iterator.next(); System.out.print(element + ' '); } System.out.println('
The Queue elements using for loop:'); //use new for loop to traverse the Queue for(Object object : LL_queue) { String element = (String) object; System.out.print(element + ' '); } } }Изход:
Елементите на опашката чрез итератор:
Стойност-0 Стойност-1 Стойност-2 Стойност-3
Елементите на опашката, използващи for цикъл:
Стойност-0 Стойност-1 Стойност-2 Стойност-3
Внедряване на Java Queue
Програмата по-долу демонстрира методите, които обсъдихме по-горе.
import java.util.*; public class Main { public static void main(String() args) { Queue q1 = new LinkedList(); //Add elements to the Queue q1.add(10); q1.add(20); q1.add(30); q1.add(40); q1.add(50); System.out.println('Elements in Queue:'+q1); //remove () method =>removes first element from the queue System.out.println('Element removed from the queue: '+q1.remove()); //element() => returns head of the queue System.out.println('Head of the queue: '+q1.element()); //poll () => removes and returns the head System.out.println('Poll():Returned Head of the queue: '+q1.poll()); //returns head of the queue System.out.println('peek():Head of the queue: '+q1.peek()); //print the contents of the Queue System.out.println('Final Queue:'+q1); } } Изход:
Елементи в опашката: (10, 20, 30, 40, 50)
Елементът е премахнат от опашката: 10
Ръководител на опашката: 20
Анкета (): Върнат ръководител на опашката: 20
peek (): Началник на опашката: 30
Финална опашка: (30, 40, 50)
Внедряване на Java Queue Array
Внедряването на опашката не е толкова лесно, колкото изпълнението на стека. На първо място, опашката съдържа два указателя, заден и преден. Също така се правят различни операции в два различни края.
За да реализираме опашка с помощта на масиви, първо декларираме масив, който ще съдържа n броя елементи на опашката.
След това дефинираме следните операции, които да бъдат изпълнени в тази опашка.
# 1) Опашка: Операция за вмъкване на елемент в опашката е Enqueue (функция queueEnqueue в програмата). За да вмъкнем елемент в задния край, първо трябва да проверим дали опашката е пълна. Ако е пълен, тогава не можем да вмъкнем елемента. Ако отзад # 2) Dequeue: Операцията за изтриване на елемент от опашката е Dequeue (функция queueDequeue в програмата). Първо проверяваме дали опашката е празна. За да работи операцията по отмяна на опашката, трябва да има поне един елемент в опашката. # 3) Отпред: Този метод връща предната част на опашката. # 4) Дисплей: Този метод обхожда опашката и показва елементите на опашката. Следващата програма Java демонстрира изпълнението на Array на Queue. Изход: Първоначална опашка: Тъй като сме внедрили структурата от данни на Queue, използвайки Arrays в горната програма, ние също можем да внедрим Queue, като използваме Linked List. Ще приложим същите методи enqueue, dequeue, front и display в тази програма. Разликата е, че вместо Array ще използваме структурата от данни на Linked List. Програмата по-долу демонстрира изпълнението на Queue List в Java. Изход: Елемент 6 добавен към опашката BlockingQueue е интерфейс, добавен в Java 1.5 и е част от java.util.concurrent пакет. Този интерфейс въвежда блокиране в случай, че BlockingQueue е пълен или празен. По този начин, когато нишка осъществява достъп до опашката и се опитва да вмъкне (постави в опашка) елементи в опашка, която вече е пълна, се блокира, докато друга нишка създаде пространство в опашката (може би чрез операция за отмяна или изчистване на опашката). По същия начин, в случай на отмяна, операцията се блокира, ако опашката е празна, докато елементът стане наличен за операцията по отмяна. Методите BlockingQueue използват някаква форма на контрол на паралелността като вътрешни ключалки и са атомни. BlockingQueue е едновременна опашка, която управлява едновременно операциите по опашката. Блокиращата опашка е показана по-долу: Имайте предвид, че BlockingQueue не приема нулеви стойности. Опитът за вмъкване на нулева стойност в опашката води до NullPointerException. Някои от изпълненията на BlockingQueue, предоставени в Java, са LinkedBlockingQueue, PriorityBlockingQueue, ArrayBlockingQueue и SynchonousQueue. Всички тези внедрения са безопасни за нишки. BlockingQueues са два вида: В ограничената опашка капацитетът на опашката се предава на конструктора на опашката. Декларацията за опашката е както следва: BlockingQueue blockingQueue = нов LinkedBlockingDeque (5); В неограничената опашка не задаваме изрично капацитета на опашката и тя може да нарасне по размер. Капацитетът е зададен на Integer.MAX_VALUE. Декларирането на неограничената опашка е както следва: BlockingQueue blockingQueue = нов LinkedBlockingDeque (); Интерфейсът BlockingQueue се използва предимно за типове проблеми производител-потребител, при които производителят произвежда ресурсите, а потребителят консумира ресурсите. В # 1) Какво представлява опашката в Java? Отговор: Опашката в Java е линейна подредена структура от данни, която следва FIFO (First In, First Out) подреждане на елементи. Това означава, че елементът, вмъкнат първи в опашката, ще бъде първият елемент, който трябва да бъде премахнат. В Java опашката е реализирана като интерфейс, който наследява интерфейса за събиране. Q # 2) Java-опасната за опашки нишка ли е? Отговор: Не всички опашки са безопасни за нишки, но BlockingQueues в Java са безопасни за нишки. Q # 3) Кое е по-бързо - стек или опашка? Отговор: Стекът е по-бърз. В стека елементите се обработват само от единия край, следователно не е необходимо преместване. Но в опашката елементите трябва да бъдат изместени и коригирани, тъй като има два различни указателя за вмъкване и изтриване на елементи. Q # 4) Какви са типовете на опашката? Отговор: Опашките са от следните типове: Q # 5) Защо се използва опашката? Отговор: Структурата на данните за опашката се използва за целите на синхронизирането. Опашката се използва и за планиране на дискове и процесори. В този урок обсъдихме простите опашки, заедно с техните подробности като декларации, изпълнение на инициализация и методи. Също така научихме за изпълнението на Array и LinkedList на Queue в Java. В предстоящите ни уроци ще обсъдим подробно повече видове опашки. => Проверете ВСИЧКИ уроци по 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
'); return; } // shift elements to the right by one place uptil rear else { for (int i = 0; i
Опашката е празна
Опашка след операция Enqueue:
10 = 30 = 50 = 70 =
Преден елемент на опашката: 10
Опашката е пълна
10 = 30 = 50 = 70 =
Опашка след две операции за отмяна: 50 = 70 =
Преден елемент на опашката: 50
безплатно приложение за карти за Android
Внедряване на свързан списък на Java Queue
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 Main{ 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(); } }
Елемент 3 добавен към опашката
Предната част на опашката: 6 Задна част на опашката: 3
Елемент 12 добавен към опашката
Елемент 24 добавен към опашката
Елемент 6 премахнат от опашката
Елемент 3 премахнат от опашката
Елемент 9 добавен към опашката
Предната част на опашката: 12 Задна част на опашката: 9
BlockingQueue в Java
Типове BlockingQueue
Ограничена опашка
Неограничена опашка
често задавани въпроси
Заключение
Препоръчително четене