Jono on toisenlainen lineaarinen tietorakenne, jota käytetään elementtien tallentamiseen aivan kuten mikä tahansa muu tietorakenne, mutta tietyllä tavalla. Yksinkertaisesti sanottuna voimme sanoa, että jono on Java-ohjelmointikielen tietorakenne, joka tallentaa samanlaisia ​​elementtejä. Jonon komponentit tallennetaan FIFO (First In, First Out) -käyttäytymiseen. Jonokokoelmassa on kaksi päätä, eli etu- ja takapää. Jonossa on kaksi päätä, etu- ja takapää.

Seuraava kuva kuvaa täydellisesti Java-jonon FIFO-ominaisuutta (First In, First Out).

dhl merkitys

Kuten edellisessä kuvassa selitettiin, voimme nähdä, että jono on lineaarinen tietorakenne, jossa on kaksi terminaalia, eli alku (etu) ja loppu (taka). Komponentit lisätään jonon sisäpuolelle jonon takapäästä ja komponentit poimitaan jonon etupäästä.

Jono on käyttöliittymä Java joka kuuluu Java.util -pakettiin. Se myös laajentaa Collection - käyttöliittymää .

Java-jonon käyttöliittymän yleinen esitys näkyy alla:

 public interface Queue extends Collection 

Kuten olemme edellä käsitelleet, että jono on rajapinta, voimme myös sanoa, että jonoa ei voida instantoida, koska rajapintoja ei voi ilmentää. Jos käyttäjä haluaa toteuttaa Queue-rajapinnan toiminnallisuuden Java-kielellä, on pakolliseksi olemassa joitakin kiinteitä luokkia, jotka toteuttavat Queue-rajapinnan.

Java-ohjelmointikielessä on kaksi eri luokkaa, joita käytetään Queue-rajapinnan toteuttamiseen. Nämä luokat ovat:

kartta koneella

• LinkedList
• PriorityQueue

Java-jonon ominaisuudet

Java-jonoa voidaan pitää yhtenä ohjelmointimaailman tärkeimmistä tietorakenteista. Java Queue on houkutteleva ominaisuuksiensa vuoksi. Java Queue -tietorakenteen tärkeät ominaisuudet on esitetty seuraavasti:

• Java-jono noudattaa FIFO-tapaa (First In, First Out). Se osoittaa, että elementit lisätään jonoon lopussa ja poistetaan etupuolelta.
• Java Queue -käyttöliittymä tarjoaa kaikki Collection-käyttöliittymän säännöt ja prosessit, kuten sisällyttämisen, poistamisen jne.
• On olemassa kaksi erilaista luokkaa, joita käytetään toteuttamaan Queue-liitäntä. Nämä luokat ovat LinkedList ja PriorityQueue.
• Näiden kahden lisäksi on olemassa luokka, joka on Array Blocking Queue, jota käytetään jonoliittymän toteuttamiseen.
• Jonoja on kahden tyyppisiä, rajoittamattomat jonot ja rajatut jonot. Jonot, jotka ovat osa java.util-pakettia, tunnetaan nimellä Unbounded jonot, ja rajatut jonot ovat jonoja, jotka ovat java.util.concurrent-paketissa.
• Deque tai (kaksipäinen jono) on myös jonotyyppi, joka sisältää elementtien sisällyttämisen ja poistamisen molemmista päistä.
• Deque katsotaan myös lankaturvalliseksi.
• Estojonot ovat myös yksi jonotyypeistä, jotka ovat myös säikeen turvallisia. Estojonoja käytetään tuottaja-kuluttaja-kyselyiden toteuttamiseen.
• Estojonot eivät tue nollaelementtejä. Jos estojonot -kohdassa yritetään toimia, jotka ovat samanlaisia ​​kuin nolla-arvot, myös NullPointerException heitetään.

Jonon toteutus

Jonon toteutuksessa käytetyt luokat

Luokat, joita käytetään jonon toimintojen toteuttamiseen, on annettu seuraavasti:

• ArrayDeque
• LinkedList
• PriorityQueue

Jonon toteutuksessa käytetyt rajapinnat

Java-rajapintoja käytetään myös Java-jonon toteutuksessa. Liitännät, joita käytetään jonon toimintojen toteuttamiseen, on annettu seuraavasti:

• Mistä
• Estojono
• Dequen estäminen

Java-jonoluokkamenetelmät

Java-jonossa on monia menetelmiä, joita käytetään hyvin yleisesti. Queue-rajapinta edistää erilaisia ​​menetelmiä, kuten insert, delete, peek jne. Jotkut Java-jonon toiminnot aiheuttavat poikkeuksen, kun taas jotkut näistä toiminnoista palauttavat tietyn arvon, kun ohjelma on valmis.

Huomautus - Java SE 8:ssa Java-jonokokoelmaan ei ole tehty muutoksia. Nämä alla määritellyt menetelmät valmistetaan edelleen Java-ohjelmointikielen seuraavissa versioissa. Esimerkiksi Java SE 9.

Java-jonon eri menetelmät on määritelty alla:

Java Queue Array -toteutus

Jonototeutus ei ole yhtä yksinkertaista kuin pinototeutus.

Toteuttaaksesi jonon taulukoiden avulla, määritämme ensin taulukon, joka sisältää n määrän elementtejä.

Sitten määritämme seuraavat toiminnot, jotka suoritetaan tässä jonossa.

1) Jono: Toiminto elementin lisäämiseksi jonoon on Enqueue (toimintojono Enqueue ohjelmassa). Jos haluat lisätä elementin takapäähän, meidän on ensin tarkistettava, onko jono täynnä. Jos se on täynnä, emme voi lisätä elementtiä. Jos takana

2) Häntä: Elementin poistaminen jonosta on Dequeue (ohjelman toimintojono Dequeue). Ensin tarkistetaan, onko jono tyhjä. Jotta jonosta poistaminen toimisi, jonossa on oltava vähintään yksi elementti.

3) Edessä: Tämä menetelmä palauttaa jonon etuosan.

vastaava merkkijono javassa

4) Näyttö: Tämä menetelmä kulkee jonon läpi ja näyttää jonon elementit.

Java-jonoohjelma

Seuraava Java-ohjelma esittelee Queuen toteutuksen.

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-jonon linkitetyn luettelon toteutus

Koska olemme toteuttaneet Queue-tietorakenteen käyttämällä Arrays-järjestelmää yllä olevassa ohjelmassa, voimme toteuttaa myös jonon käyttämällä linkitettyä listaa.

Toteutamme samat menetelmät enqueue, dequeue, front ja display tässä ohjelmassa. Erona on, että käytämme Linked List -tietorakennetta Array:n sijaan.

Alla oleva ohjelma esittelee jonon Linked List -toteutuksen Javassa.

QueueLLimplementation.java

estetyt yhteystiedot

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

Lähtö:

 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