pila

Para sa karamihan ng mga tao, ang salitang "pila" ay nagpapaalala sa napakakaunting mga kaaya-ayang samahan. Ngunit ngayon ay pinag-uusapan natin ang tungkol sa iba't ibang mga pila — mga pila ng Java. Sa Java, ang queue ay anumang bagay na nagmamana ng interface ng Queue , na nagpapalawak naman ng interface ng Collection . Nangangahulugan iyon na ang mga pila ay maaaring ituring na parang mga koleksyon.

Sinusuportahan ng mga queue sa Java ang dalawang prinsipyo ng pagpapatakbo: FIFO at LIFO .

Ang prinsipyo ng FIFO (First In, First Out) ay namamahala sa isang regular na pila — ang unang elementong idinagdag sa pila ay ang unang umalis dito.

Ang prinsipyo ng LIFO (Last In, First Out) ay naglalarawan sa gawi ng isang stack — ang huling elementong idinagdag sa pila ay ang unang aalis dito. Halimbawa, ito ay kung paano ka nagtatrabaho sa isang deck ng mga baraha: isa-isang alisin ang mga card sa itaas hanggang sa maabot mo ang ibaba ng deck.

Ang hierarchy ng Queue sa Java ay ganito ang hitsura:

Dito makikita mo na ang Queue ay may 3 mga klase ng pagpapatupad: LinkedList , ArrayDeque at PriorityQueue . Direktang nagmamana ang LinkedList at ArrayDeque hindi Queue , ngunit Deque .

Ang Deque ay isang interface na idinagdag sa Java 6. Kabilang dito ang ilang mga pamamaraan na kapaki-pakinabang para sa mga queue at nagbibigay-daan sa isang queue na gumana bilang isang double-ended (o bidirectional) na pila. Ibig sabihin maaari itong magingFIFOatLIFO.

Isa sa dalawang inapo ng Deque interface ay ArrayDeque . Sinusuportahan nito ang doubled-ended queue na hinahayaan kang magpasok at mag-alis ng mga elemento mula sa magkabilang dulo. Isa rin itong dynamic na array na awtomatikong lumalaki sa laki.

Mayroon ding PriorityQueue na klase, na direktang inapo ng Queue : iba ang kilos nito kaysa sa mga klase na nagpapatupad ng Deque .

Ang PriorityQueue ay isang priority queue na nag-aayos ng mga elemento ayon sa kanilang natural na pagkakasunud-sunod bilang default. Dito ginagamit ng pag-uuri ang mga interface ng Comparable at Comparator . Ang prinsipyo ay kapareho ng sa TreeSet o TreeMap — mga klase na gumagamit ng Comparable interface at may sariling pagkakasunud-sunod.

PriorityQueue<String> priorityQueue = new PriorityQueue<>(Comparator.comparingInt(String::length));

priorityQueue.add("Andrew");
priorityQueue.add("John");
priorityQueue.add("Rob");

while (!priorityQueue.isEmpty()) {
   System.out.println(priorityQueue.remove());
}

Kung patakbuhin mo ang halimbawang ito, narito ang makikita mo sa console:

Dahil nagtatrabaho kami sa mga pila at hindi sa mga regular na koleksyon, kailangan naming alisin ang mga elemento mula sa listahan. Upang gawin ito, ginagamit namin ang konstruksyon na ito:

while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.remove());
}

Ang Deque interface ay nagmamana ng mga pamamaraan ng Queue at nagdaragdag ng ilan sa sarili nitong mga kawili-wiling pamamaraan:

Tingnan natin ngayon ang ilan sa mga pamamaraang ito sa pagsasagawa.

Una, magdagdag tayo ng elemento sa isang queue:

Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple"); // Adds "Apple" to the end of the queue
        deque.addFirst("Orange"); // Adds "Orange" to the front of the queue
        deque.addLast("Pineapple"); // Adds "Pineapple" to the end of the queue

        System.out.println(deque);

Ngayon, kumuha tayo ng mga halaga mula sa isang queue:

Deque<String> deque = new ArrayDeque<>();

deque.add("Apple");
        deque.addFirst("Orange");
        deque.addLast("Pineapple");


        System.out.println("The first element is: "+ deque.getFirst());

        System.out.println("The last element is: " + deque.getLast());

    }

Ipinapakita ng code na ito ang una at huling elemento ng pila.

Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple");
        deque.addFirst("Orange");
        deque.addLast("Pineapple");
        deque.add("Lemon");

System.out.println(deque.pop()); // Get and remove the first element of the queue
System.out.println(deque.poll()); // Get and remove the first element of the queue

System.out.println(deque);

Sa pagpapatakbo ng code na ito, makakakuha tayo ng:

Ang pagkakaiba sa pagitan ng pop() at poll() ay ang pop() ay magtapon ng NoSuchElementException kung ang listahan ay walang laman na listahan, ngunit ang poll() ay magbabalik null .

Ngayon ay isasaalang-alang natin ang pollFirst() at pollLast() na mga pamamaraan.

Deque<String> deque = new ArrayDeque<>();

        deque.add("Apple");
        deque.addFirst("Orange");
        deque.addLast("Pineapple");
        deque.add("Lemon");

System.out.println(deque.pollFirst()); // Get and remove the first element of the queue
System.out.println(deque.pollLast()); // Get and remove the last element of the queue.
System.out.println(deque);

Ang parehong mga pamamaraan ay bumabalik at nag-aalis ng isang halaga mula sa pila.

Narito ang isang halimbawa ng paggamit ng mga pamamaraan ng peekFirst() at peekLast() :

Deque<String> friends = new ArrayDeque<>();

friends.add("John");
friends.add("Rob");
friends.add("Greg");
friends.add("Max");
friends.add("Oliver");

System.out.println("The first element is: " + friends.peekFirst());
System.out.println("The last element is: " + friends.peekLast());

System.out.println(friends);

Ang parehong mga pamamaraan ay nagbabalik ng una/huling elemento mula sa pila at huwag alisin ang mga ito. Kung walang laman ang pila, ibabalik ang null .

Magaling! Ngayon natutunan namin kung paano gumawa ng mga queues sa Java. Ngayon alam mo na kung paano gamitin ang mga ito sa pagsasanay.