Meny

Java Stack Tutorial: Stack Class Implementation With Eksempler

  • Hoved
  • Annen
  • Java Stack Tutorial: Stack Class Implementation With Eksempler

java stack tutorial stack class implementation with examples

Prøv Instrumentet Vårt For Å Eliminere Problemer

Denne opplæringen forklarer hva som er Stack i Java, Java Stack Class, Stack API Methods, Stack Implementation ved hjelp av Array & Linked List ved hjelp av eksempler:

En stabel er en ordnet datastruktur som tilhører Java Collection Framework. I denne samlingen blir elementene bare lagt til og fjernet fra den ene enden. Slutten som elementene blir lagt til og fjernet, kalles “Top of the Stack”.

Ettersom tillegg og sletting bare gjøres i den ene enden, er det første elementet som legges til bunken, det siste elementet fjernet fra bunken. Dermed kalles stack en LIFO (Last-in, First-out) datastruktur.

=> Ta en titt på Java Beginners Guide her

Stack Collection i Java

Hva du vil lære:

Java Stack Collection

En billedlig fremstilling av stabelen er gitt nedenfor.

billedlig fremstilling av stabelen

Som vist i den ovennevnte sekvens av representasjon, er bunken først tom og toppen av bunken er satt til -1. Deretter starter vi en 'push' -operasjon som brukes til å legge til et element i bunken.

Så i den andre representasjonen skyver vi element 10. På dette punktet er toppen inkrementert. Vi skyver igjen elementet 20 i stabelen for derved å øke toppen.

I den siste representasjonen initierte vi en 'pop' -operasjon. Denne operasjonen brukes til å fjerne et element fra bunken. Et element som for tiden peker mot ‘Topp’ fjernes av popoperasjonen.

En stabeldatastruktur støtter følgende operasjoner:

  • Trykk: Legger til et element i bunken. Som et resultat økes verdien på toppen.
  • Pop: Et element fjernes fra bunken. Etter popoperasjonen blir verdien på toppen redusert.
  • Titt: Denne operasjonen brukes til å slå opp eller søke etter et element. Verdien på toppen er ikke endret.

Toppen av stabelen som brukes som en slutt for å legge til / fjerne elementer fra stabelen, kan også ha forskjellige verdier i et bestemt øyeblikk. Hvis størrelsen på stabelen er N, vil toppen av stabelen ha følgende verdier under forskjellige forhold, avhengig av hvilken tilstand stabelen er i.

Status for stabelenTopp verdi
Stabel tom-1
Ett element i bunken0
Stakk fullN-1
Overløp (elementer> N)N

Stakk klasse i Java

Java Collection Framework tilbyr en klasse som heter 'Stack'. Denne Stack-klassen utvider Vector-klassen og implementerer funksjonaliteten til Stack-datastrukturen.

Diagrammet nedenfor viser hierarkiet til Stack-klassen.

Hierarki av stakklasse i Java

Som vist i diagrammet ovenfor, arver Stack-klassen Vector-klassen som igjen implementerer List Interface of Collection-grensesnittet.

Stack-klassen er en del av java.util-pakken. For å inkludere Stack-klassen i programmet kan vi bruke importuttalelsen som følger.

import java.util.*;

eller

import java.util.Stack;

Lag en stabel i Java

Når vi har importert Stack-klassen, kan vi opprette et Stack-objekt som vist nedenfor:

Stack mystack = new Stack();

Vi kan også lage en generisk type Stack-klasseobjekt som følger:

den beste youtube til mp3-omformeren
Stack myStack = new Stack;

Her kan data_type være en hvilken som helst gyldig datatype i Java.

For eksempel ,vi kan lage følgende Stack-klasseobjekter.

Stack stack_obj = new Stack(); Stack str_stack = new Stack();

Stack API-metoder i Java

Stack-klassen gir metoder for å legge til, fjerne og søke data i Stack. Det gir også en metode for å sjekke om bunken er tom. Vi vil diskutere disse metodene i avsnittet nedenfor.

Stack Push-operasjon

Push-operasjonen brukes til å skyve eller legge til elementer i bunken. Når vi har opprettet en stabelforekomst, kan vi bruke push-operasjonen for å legge til elementene av stabelobjekt-typen til stakken.

Følgende kodebit brukes til å initialisere en heltallstabel med verdiene.

Stack myStack = new Stack(); myStack.push(10); myStack.push(15); myStack.push(20);

Den innledende stakken oppnådd som et resultat av ovennevnte kodeutførelse vises nedenfor:

innledende stabel

Hvis vi utfører en annen trykk () -operasjon som vist nedenfor,

push(25);

Den resulterende stakken blir:

Den resulterende stakken

Stack Pop-operasjon

Vi kan fjerne elementet fra stakken ved hjelp av 'pop' -operasjonen. Elementet som er pekt av toppen for tiden, er spratt av bunken.

Følgende kode oppnår dette.

Stack intStack = new Stack(); intStack.push(100); intStack.push(200); int val = intStack.pop();

Den variable val vil inneholde verdien 200 da det var det siste elementet som ble presset inn i bunken.

Stakkrepresentasjonen for trykk- og popoperasjon er som følger:

trykk og pop-operasjon

Stack Peek-operasjon

Tittoperasjonen returnerer toppen av bunken uten å fjerne elementet. I stakkeksemplet ovenfor vil “intStack.peek ()” returnere 200.

Stack er tom drift

Operasjonen isEmpty () i Stack-klassen kontrollerer om stack-objektet er tomt. Det returnerer sant hvis stakken ikke har noen elementer i den, ellers returnerer den falsk.

Stack Search-operasjon

Vi kan søke etter et element på bunken ved hjelp av søk () -operasjonen. Søke () -operasjonen returnerer indeksen til elementet det søkes etter. Denne indeksen telles fra toppen av bunken.

Stack intStack = new Stack (); intStack.push (100); intStack.push (200); int index = inStack.search(100); //index will have the value 2.

Stakkstørrelse

Størrelsen på Stack-objektet er gitt av java.util.Stack.size () metode. Det returnerer det totale antallet elementer i stakken.

Følgende eksempel skriver ut stabelstørrelsen.

Stack myStack = new Stack(); myStack.push(100); myStack.push(200); myStack.push(300); System.out.println('Stack size:' + myStack.size()); //Stack size: 3

Skriv ut / Iterate Stack Elements

Vi kan erklære en iterator for Stack og deretter krysse gjennom hele Stack ved hjelp av denne iteratoren. På denne måten kan vi besøke og skrive ut hvert stackelement en etter en.

Det følgende programmet viser måten å gjenta Stack ved hjelp av en iterator.

import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements:'); //get an iterator for the stack Iterator iterator = stack.iterator(); //traverse the stack using iterator in a loop and print each element while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } }

Produksjon:

Stabelelementer:
PUNE MUMBAI NASHIK

Stakk utdata

Stakk ved hjelp av Java 8

Vi kan også skrive ut eller krysse stabelelementene ved hjelp av Java 8-funksjoner som Stream API-er, forEach og forEachRemaining-konstruksjoner.

Det følgende programmet viser bruken av Java 8-konstruksjoner for å krysse gjennom bunken.

import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements using Java 8 forEach:'); //get a stream for the stack Stream stream = stack.stream(); //traverse though each stream object using forEach construct of Java 8 stream.forEach((element) -> { System.out.print(element + ' '); // print element }); System.out.println(' Stack elements using Java 8 forEachRemaining:'); //define an iterator for the stack Iterator stackIterator = stack.iterator(); //use forEachRemaining construct to print each stack element stackIterator.forEachRemaining(val -> { System.out.print(val + ' '); }); } }

Produksjon:

Stabel elementer ved hjelp av Java 8 forEach:
PUNE MUMBAI NASHIK
Stabel elementer ved hjelp av Java 8 forEachRemaining:
PUNE MUMBAI NASHIK

output - Stack ved hjelp av Java 8

Stakkimplementering i Java

Følgende program implementerer den detaljerte stakken som demonstrerer de forskjellige stakkoperasjonene.

import java.util.Stack; public class Main { public static void main(String a()){ //declare a stack object Stack stack = new Stack(); //print initial stack System.out.println('Initial stack : ' + stack); //isEmpty () System.out.println('Is stack Empty? : ' + stack.isEmpty()); //push () operation stack.push(10); stack.push(20); stack.push(30); stack.push(40); //print non-empty stack System.out.println('Stack after push operation: ' + stack); //pop () operation System.out.println('Element popped out:' + stack.pop()); System.out.println('Stack after Pop Operation : ' + stack); //search () operation System.out.println('Element 10 found at position: ' + stack.search(10)); System.out.println('Is Stack empty? : ' + stack.isEmpty()); } }

Produksjon:

Innledende stabel: ()
Er stakken tom? : sant
Stabel etter trykkoperasjon: (10, 20, 30, 40)
Element spratt ut: 40
Stack etter popoperasjon: (10, 20, 30)
Element 10 funnet ved posisjon: 3
Er Stack tom? : falsk

output - Stack Implementation

hvordan du kjører jar-filer på Windows 10

Stakk for å arrangere i Java

Stakkedatastrukturen kan konverteres til en matrise ved hjelp av 'toArray ()' -metoden i Stack-klassen.

Følgende program demonstrerer denne konverteringen.

import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); //print the stack System.out.println('The Stack contents: ' + stack); // Create the array and use toArray() method to convert stack to array Object() strArray = stack.toArray(); //print the array System.out.println('The Array contents:'); for (int j = 0; j

Produksjon:

Stack-innholdet: (PUNE, MUMBAI, NASHIK)
Array-innholdet:
PUNE MUMBAI NASHIK

utgang - STABEL TIL ARRAY I JAVA

Stakkimplementering i Java ved hjelp av Array

Stakken kan implementeres ved hjelp av en Array. Alle stableoperasjoner utføres ved hjelp av en matrise.

Programmet nedenfor demonstrerer Stack-implementeringen ved hjelp av en matrise.

import java.util.*; //Stack class class Stack { int top; //define top of stack int maxsize = 5; //max size of the stack int() stack_arry = new int(maxsize); //define array that will hold stack elements Stack(){ //stack constructor; initially top = -1 top = -1; } boolean isEmpty(){ //isEmpty () method return (top <0); } boolean push (int val){ //push () method if(top == maxsize-1) { System.out.println('Stack Overflow !!'); return false; } else { top++; stack_arry(top)=val; return true; } } boolean pop () { //pop () method if (top == -1) { System.out.println('Stack Underflow !!'); return false; } else { System.out.println(' Item popped: ' + stack_arry(top--)); return true; } } void display () { //print the stack elements System.out.println('Printing stack elements .....'); for(int i = top; i>=0;i--) { System.out.print(stack_arry(i) + ' '); } } } public class Main { public static void main(String() args) { //define a stack object Stack stck = new Stack(); System.out.println('Initial Stack Empty : ' + stck.isEmpty()); //push elements stck.push(10); stck.push(20); stck.push(30); stck.push(40); System.out.println('After Push Operation...'); //print the elements stck.display(); //pop two elements from stack stck.pop(); stck.pop(); System.out.println('After Pop Operation...'); //print the stack again stck.display(); } }

Produksjon:

Initial Stack Empty: true
Etter Push-operasjon ...
Skriver ut stabelelementer ... ..
40 30 20 10
Vare poppet opp: 40

Vare poppet opp: 30
Etter popoperasjon ...
Skriver ut stabelelementer ... ..
20 10

hvordan du åpner et sjokkbølge-flash-objekt

output - Stackimplementering i java ved hjelp av array

Stakkimplementering ved hjelp av koblet liste

Stakken kan også implementeres ved hjelp av en koblet liste, akkurat som hvordan vi har gjort det ved hjelp av arrays. En fordel med å bruke en koblet liste for å implementere stack er at den kan vokse eller krympe dynamisk. Vi trenger ikke ha en maksimal størrelsesbegrensning som i matriser.

Følgende program implementerer en koblet liste for å utføre stabeloperasjoner.

import static java.lang.System.exit; // Stack class using LinkedList class Stack_Linkedlist { // Define Node of LinkedList private class Node { int data; // node data Node nlink; // Node link } // top of the stack Node top; // stack class Constructor Stack_Linkedlist() { this.top = null; } // push () operation public void push(int val) { // create a new node Node temp = new Node(); // checks if the stack is full if (temp == null) { System.out.print(' Stack Overflow'); return; } // assign val to node temp.data = val; // set top of the stack to node link temp.nlink = top; // update top top = temp; } // isEmpty () operation public boolean isEmpty() { return top == null; } // peek () operation public int peek() { // check if the stack is empty if (!isEmpty()) { return top.data; } else { System.out.println('Stack is empty!'); return -1; } } // pop () operation public void pop() { // check if stack is out of elements if (top == null) { System.out.print(' Stack Underflow!!'); return; } // set top to point to next node top = (top).nlink; } //print stack contents public void display() { // check for stack underflow if (top == null) { System.out.printf(' Stack Underflow!!'); exit(1); } else { Node temp = top; System.out.println('Stack elements:'); while (temp != null) { // print node data System.out.print(temp.data + '->'); // assign temp link to temp temp = temp.nlink; } } } } public class Main { public static void main(String() args) { // Create a stack class object Stack_Linkedlist stack_obj = new Stack_Linkedlist(); // push values into the stack stack_obj.push(9); stack_obj.push(7); stack_obj.push(5); stack_obj.push(3); stack_obj.push(1); // print Stack elements stack_obj.display(); // print current stack top System.out.println(' Stack top : ' + stack_obj.peek()); // Pop elements twice System.out.println('Pop two elements'); stack_obj.pop(); stack_obj.pop(); // print Stack elements stack_obj.display(); // print new stack top System.out.println(' New Stack top:' + stack_obj.peek()); } }

Produksjon:

Stabelelementer:
1-> 3-> 5-> 7-> 9->

Stabel topp: 1
Popp to elementer
Stabelelementer:
5-> 7-> 9->

Ny stabeltopp: 5

output - Stackimplementering ved hjelp av en koblet liste

ofte stilte spørsmål

Q # 1) Hva er stabler i Java?

Svar: En stabel er en LIFO (Last in, First out) datastruktur for lagring av elementer. Stabelelementene legges til eller fjernes fra stakken fra den ene enden som kalles toppen av stakken.

Tillegg av et element til stabelen gjøres ved hjelp av Push-operasjonen. Sletting av elementer gjøres ved hjelp av popoperasjon. I Java implementeres en stack ved hjelp av Stack-klassen.

Q # 2) Er Stack en samling i Java?

Svar: Ja. Stakken er en eldre samling i Java som er tilgjengelig fra Collection API i Java 1.0 og utover. Stack arver vektorklassen til List-grensesnittet.

Q # 3) Er Stack et grensesnitt?

Svar: Interface stack er et grensesnitt som beskriver den siste inn-først ut-strukturen og brukes til å lagre tilstanden til rekursive problemer.

Sp # 4) Hva brukes stabler til?

Svar: Følgende er hovedapplikasjonene i stakken:

  • Uttrykk evaluering og konvertering: Stack brukes til å konvertere uttrykk til postfix, infix og prefix. Det brukes også til å evaluere disse uttrykkene.
  • Stabelen brukes også til å analysere syntaksetrær.
  • Stakken brukes til å sjekke parenteser i et uttrykk.
  • Stakken brukes til å løse tilbakesporingsproblemer.
  • Funksjonsanrop evalueres ved hjelp av stabler.

Sp # 5) Hva er fordelene med stabelen?

Svar: Variabler som er lagret på stabelen blir ødelagt automatisk når de returneres. Stabler er et bedre valg når minne tildeles og fordeles. Stabler rydder også opp minnet. Bortsett fra at stabler kan brukes effektivt til å evaluere uttrykk og analysere uttrykkene.

Konklusjon

Dette fullfører opplæringen vår om stabler i Java. Stack-klassen er en del av samlingen API og støtter push-, pop-, peek- og søkeoperasjoner. Elementene legges til eller fjernes til / fra bunken bare i den ene enden. Denne enden kalles toppen av bunken.

I denne veiledningen har vi sett alle metodene som støttes av stack-klassen. Vi har også implementert stakken ved hjelp av arrays og lenkede lister.

Vi vil fortsette med andre samlingsklasser i de påfølgende opplæringene våre.

=> Les gjennom Easy Java Training Series

Anbefalt lesing

^