Eilė yra kitos rūšies linijinė duomenų struktūra, kuri naudojama elementams saugoti, kaip ir bet kuri kita duomenų struktūra, bet tam tikru būdu. Paprastais žodžiais tariant, eilė yra tam tikros rūšies duomenų struktūra Java programavimo kalba, kurioje saugomi tos pačios rūšies elementai. Eilėje esantys komponentai saugomi FIFO (pirmas įėjimas, pirmasis išėjimas) elgesys. Eilių rinkinyje yra du galai, t. y. priekinis ir galinis. Eilė turi du galus – priekyje ir gale.

Toliau pateiktame paveikslėlyje puikiai aprašyta „Java“ eilės FIFO (First In, First Out) savybė.

Kaip paaiškinta ankstesniame paveikslėlyje, matome, kad eilė yra linijinė duomenų struktūra su dviem gnybtais, ty pradžia (priekyje) ir pabaiga (galinė). Komponentai į eilę įtraukiami iš eilės galinės dalies, o komponentai ištraukiami iš priekinės eilės galo.

Eilė yra sąsaja Java kuris priklauso Java.util paketui . Taip pat praplečiama Kolekcijos sąsaja.

java interviu klausimai

Žemiau parodytas bendras „Java Queue“ sąsajos vaizdas:

 public interface Queue extends Collection 

Kaip jau aptarėme aukščiau, kad eilė yra sąsaja, todėl taip pat galime sakyti, kad eilė negali būti kartojama, nes sąsajos negali būti kartojamos. Jei vartotojas nori įdiegti „Java“ eilės sąsajos funkcionalumą, privaloma turėti keletą tvirtų klasių, kurios įdiegtų „Queue“ sąsają.

Java programavimo kalboje yra dvi skirtingos klasės, kurios naudojamos eilės sąsajai įgyvendinti. Šios klasės yra:

• LinkedList
• PriorityQueue

„Java“ eilės ypatybės

„Java Queue“ gali būti laikoma viena iš svarbiausių duomenų struktūrų programavimo pasaulyje. „Java Queue“ yra patraukli dėl savo savybių. Svarbios „Java Queue“ duomenų struktūros savybės pateikiamos taip:

• „Java Queue“ paklūsta FIFO (pirmas įėjimas, pirmasis išėjimas) būdui. Tai rodo, kad elementai įvedami į eilę pabaigoje ir pašalinami iš priekio.
• „Java Queue“ sąsajoje pateikiamos visos kolekcijos sąsajos taisyklės ir procesai, pvz., įtraukimas, ištrynimas ir kt.
• Yra dvi skirtingos klasės, kurios naudojamos eilės sąsajai įgyvendinti. Šios klasės yra LinkedList ir PriorityQueue.
• Išskyrus šias dvi, yra klasė, kuri yra masyvo blokavimo eilė, kuri naudojama eilės sąsajai įdiegti.
• Yra dviejų tipų eilės: neapribotos eilės ir ribotos eilės. Eilės, kurios yra java.util paketo dalis, yra žinomos kaip neapribotos eilės, o apribotos eilės yra java.util.concurrent pakete esančios eilės.
• Deque arba (dviejų galų eilė) taip pat yra eilės tipas, į kurį įtraukiami ir ištrinami elementai iš abiejų galų.
• Deque taip pat laikomas saugiu siūlams.
• Blokavimo eilės taip pat yra vienas iš eilių, kurios taip pat yra saugios nuo gijų, tipų. Blokavimo eilės naudojamos gamintojo ir vartotojo užklausoms įgyvendinti.
• Blokavimo eilės nepalaiko nulinių elementų. Blokavimo eilėse, jei bandomas koks nors darbas, panašus į nulines reikšmes, taip pat bus metamas NullPointerException.

Eilės įgyvendinimas

Klasės, naudojamos diegiant eilę

Klasės, kurios naudojamos eilės funkcijoms įgyvendinti, pateikiamos taip:

• ArrayDeque
• LinkedList
• PriorityQueue

Sąsajos, naudojamos diegiant eilę

„Java“ sąsajos taip pat naudojamos įdiegiant „Java“ eilę. Sąsajos, kurios naudojamos eilės funkcijoms įgyvendinti, pateikiamos taip:

• Apie ką
• Blokavimo eilė
• Deque blokavimas

Java eilių klasės metodai

„Java“ eilėje yra daug metodų, kurie naudojami labai dažnai. Eilės sąsaja skatina įvairius metodus, pvz., įterpimą, trynimą, žvilgsnį ir tt Kai kurios „Java“ eilės operacijos kelia išimtį, o kai kurios iš šių operacijų grąžina tam tikrą reikšmę, kai programa baigta.

np taškas

Pastaba – „Java SE 8“ „Java“ eilių rinkinyje nėra jokių pakeitimų. Šie metodai, kurie yra apibrėžti toliau, yra paruošti vėlesnėse Java programavimo kalbos versijose. Pavyzdžiui, Java SE 9.

Įvairūs Java eilės metodai yra apibrėžti toliau:

Java eilių masyvo įgyvendinimas

Eilių diegimas nėra toks paprastas kaip dėklo įgyvendinimas.

Norėdami įdiegti eilę naudodami masyvus, pirmiausia deklaruojame masyvą, kuriame yra n elementų skaičius.

Tada apibrėžiame šias operacijas, kurios turi būti atliekamos šioje eilėje.

1) Eilė: Elemento įterpimo į eilę operacija yra Enqueue (programoje funkcija eilė Enqueue). Norėdami įterpti elementą galinėje dalyje, pirmiausia turime patikrinti, ar eilė pilna. Jei jis pilnas, elemento įterpti negalime. Jei galinis

2) Uodega: Elemento ištrynimo iš eilės operacija yra Dequeue (programoje funkcija queue Dequeue). Pirmiausia patikriname, ar eilė tuščia. Kad ištraukimo iš eilės operacija veiktų, eilėje turi būti bent vienas elementas.

3) priekis: Šis metodas grąžina eilės priekį.

4) Ekranas: Šis metodas eina per eilę ir parodo eilės elementus.

Java eilės programa

Ši Java programa demonstruoja eilės įgyvendinimą.

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>

„Java Queue Linked List“ diegimas

Kadangi pirmiau pateiktoje programoje įdiegėme eilės duomenų struktūrą naudodami masyvus, eilę galime įdiegti ir naudodami susietą sąrašą.

Šioje programoje įdiegsime tuos pačius eilės, eilės, fronto ir rodymo metodus. Skirtumas tas, kad mes naudosime susieto sąrašo duomenų struktūrą, o ne masyvą.

Toliau pateiktoje programoje parodytas susietojo sąrašo eilės diegimas Java programoje.

reaguoti-lentelė

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(); } } 

Išvestis:

 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