Ang Stack sa Java ay isang istraktura ng data, katulad ng isang queue, array, naka-link na listahan, o puno. Kung saan ito naiiba sa iba ay ang Java Stack ay batay sa Huling In, Unang Out (LIFO) na prinsipyo. Ang ibig sabihin nito ay kapag ginamit mo ang dalawang utos upang magdagdag at mag-alis ng isang elemento mula sa stack, ang unang aalisin mo ay palaging ang huling idinagdag mo. Tingnan natin ang Java Stack Class
Paggalugad sa Java Stack Class
Ang Java Stack Class ay isang extension ng Vector class, na mismong nagpapalawak ng List class. Dahil ang mga vector ay nababago at maaaring lumaki at lumiit sa mga hinihingi ng mga elemento sa loob, ang Stack s ay maaari ding magbago ng mga laki kapag hinihiling. Ang extension ng Vector class ay nagdaragdag ng limang operasyon na nagpapabago sa isang Vector sa isang Stack . Ang limang operasyong ito ay:
.push(E item) – naglalagay ng elemento sa tuktok ng stack
.pop() – inaalis ang elemento sa tuktok ng stack at ibinabalik ito bilang halaga ng function
.peek() – tinitingnan ang elemento sa tuktok ng stack nang hindi ito inaalis
.empty() – Boolean function upang subukan kung ang stack ay walang laman o wala. Nagbabalik ng 0 o 1.
.search(Object o) – Hinahanap ang o at ibinalik ang posisyon nito. Ang value ay 1-based, hindi 0-based
Namana rin ng Stack ang lahat ng mga pamamaraan na bahagi ng Vector , kabilang ngunit hindi limitado sa, toString() , contains() , indexOf() , at lastElement() .
Pag-coding ng Halimbawa ng Java Stack
Ngayong alam na natin ang mga function para sa Stack , mag-code tayo ng halimbawa ng java stack. Ang mga stack ay lubhang kapaki-pakinabang para sa paghawak ng data na dapat pansamantalang iimbak at mabilis na makuha. Dahil ang Stack ay LIFO, ito ay lubhang kapaki-pakinabang para sa node traversal kapag nag-explore ng isang tree data structure. Bago tayo pumasok sa lahat ng iyon, gumawa tayo ng pangunahing stack. Ang code para ipatupad ang isang stack ay ang mga sumusunod:
import java.util.*;
class Main {
public static void main(String[] args) {
Stack<Integer> stackExample = new Stack<Integer>();
Iyon lang ang kailangan mong gawin upang lumikha ng walang laman na Stack . Maaari mo ring ideklara ito nang simple nang hindi nagdedeklara ng uri ng data sa pamamagitan ng paggamit ng:
Stack example = new Stack();
Tandaan na dahil nababago ang Stack s, habang itinutulak namin ang mga elemento sa stack, awtomatiko itong magsasaayos sa laki. Ngayon tingnan natin kung paano gamitin ang mga function ng Stack .
Pagpapatupad ng Java Stack
Tingnan natin kung paano gamitin ang limang pamamaraan na na-explore natin kanina. Ang pagpapatupad ng Java stack ay madaling matandaan kung iisipin mo ito bilang isang stack ng mga plato. Naglalagay ka ng mga plato sa salansan, ngunit upang makakuha ng isang plato, hindi ka pupunta sa ibaba, makakakuha ka ng isa mula sa itaas. Ang huli mong isuot ay ang una mong hinuhubad. Ang pagpapalawak ng aming nakaraang halimbawa sa stackExample , ang mga function ay ang mga sumusunod:
Itulak
// pushing integers onto the Stack
stackExample.push(5);
stackExample.push(10);
Sa puntong ito, ipapakita namin ang iba pang mga function na parang itinulak namin ang dalawang integer na ito sa halimbawa ng Java stack sa bawat oras.
Pop
//popping integers off of the Stack
System.out.println(stackExample.pop());
System.out.println(stackExample.pop());
Output:
10
5
Walang laman
Ngayon, sabihin nating gusto mong tanggalin ang lahat ng elemento sa isang Stack ngunit hindi ka sigurado kung gaano karaming elemento ang mayroon. Maaari mong pagsamahin ang Boolean.isEmpty() function na may precondition while loop para i-pop ang lahat ng elemento mula sa Stack . Tingnan kung paano ginagawa ang pagpapatupad ng java stack na ito.
Maaari naming gamitin ang .peek() bilang pagpapatupad ng stack sa Java upang tingnan ang susunod na item sa Stack nang hindi ito inaalis.
System.out.println(stackExample.peek());
Output
10
Kung i-pop at i-print natin ang Stack , babalik ito ng 10 at 5 dahil nasa stack pa rin ang 10. Tiningnan lang namin, hindi namin tinanggal gamit ang pop function. Ang peek function ay isang mahusay na tool para sa Stack s sa java.
Maghanap
Kung gusto naming makahanap ng isang partikular na elemento, ang pagpapatupad ng mga stack sa Java ay gumagamit ng .search(e); upang mahanap ito.
System.out.println(stackExample.search(5));
Output
2
Tandaan na ito ay dahil nagbibilang tayo mula sa tuktok ng Stack at ang Java Stack ay nagsisimula sa 1, hindi 0 tulad ng isang Array . Kaya, sa pagtingin sa stack, ito ay (10) --> (5), at 5 ay nasa numero 2 na puwesto. Kung susubukan mong maghanap ng elemento na wala sa Stack , makakakuha ka ng -1 bilang isang output.
Inuulit
Kapag nagtatrabaho sa anumang koleksyon, maaaring may mga oras na kailangan mong maghanap ng maraming elemento. Upang i-save ang pagiging kumplikado at kailangang maghanap sa Stack nang maraming beses, maaari mong gamitin ang pag-ulit. Dahil pinalawak ng Stack sa Java ang klase ng Listahan , mayroong ilang mga opsyon para sa pag-ulit. Isa sa pinakamadali ay ang paggamit lamang ng ListIterator function. Ang ListIterator ay maganda dahil hinahayaan ka nitong tumawid sa isang Stack mula sa itaas hanggang sa ibaba o mula sa ibaba hanggang sa itaas gamit ang .hasPrevious() o .hasNext() . Narito ang hitsura nito:
ListIterator<Integer> exampleIterator = stackExample.listIterator(stackExample.size());
while (exampleIterator.hasPrevious()) {
int iteration = exampleIterator.previous();
System.out.println(iteration);
}
Output
10
5
Tandaan na kapag umulit ka sa Stack s sa Java, hindi mo aalisin ang anumang elemento dito. Ang pag-ulit ay nagbibigay-daan sa iyo upang silipin ang bawat elemento sa stack sa pagkakasunud-sunod. Kapag ginawa mo ito, maaari kang maghanap ng mga lokasyon kung nasaan ang ilang partikular na elemento at pagkatapos ay dumaan at manipulahin ang mga ito. Maaari mong bilangin, tanggalin, o kahit na baguhin ang mga ito kung kinakailangan.
GO TO FULL VERSION