java stack tutorial stack class implementation with examples
Denna handledning förklarar vad som är Stack i Java, Java Stack Class, Stack API Methods, Stack Implementation med hjälp av Array & Linked List med hjälp av exempel:
En stack är en ordnad datastruktur som tillhör Java Collection Framework. I den här samlingen läggs elementen bara till och tas bort från ena änden. Slutet vid vilket elementen läggs till och tas bort kallas ”Top of the Stack”.
Eftersom addition och radering endast görs i ena änden, råkar det första elementet som läggs till i stacken vara det sista elementet som tas bort från stacken. Således kallas stack en LIFO (Last-in, First-out) datastruktur.
=> Ta en titt på Java-nybörjarguiden här
Vad du kommer att lära dig:
- Java Stack Collection
- Slutsats
Java Stack Collection
En bildrepresentation av stacken ges nedan.
Som visas i ovanstående representationssekvens är stapeln initialt tom och toppen av stapeln är inställd på -1. Sedan initierar vi en 'push' -operation som används för att lägga till ett element i stacken.
Så i den andra representationen trycker vi på element 10. Vid denna punkt ökas toppen. Vi skjuter igen elementet 20 i stapeln, varigenom toppen ökas ytterligare.
I den sista representationen inledde vi en 'pop' -operation. Denna åtgärd används för att ta bort ett element från stacken. Ett element som för närvarande pekas på 'Top' tas bort av popoperationen.
En stapeldatastruktur stöder följande operationer:
- Skjuta på: Lägger till ett element i stacken. Som ett resultat ökas toppens värde.
- Pop: Ett element tas bort från stacken. Efter popoperationen minskas värdet på toppen.
- Titt: Denna operation används för att leta upp eller söka efter ett element. Värdet på toppen ändras inte.
Överst på stacken som används som ett slut för att lägga till / ta bort element från stacken kan också ha olika värden vid ett visst ögonblick. Om stapelns storlek är N, kommer stapelns överdel att ha följande värden vid olika förhållanden beroende på vilket tillstånd stacken är i.
| Stackens status | Toppvärde |
|---|---|
| Stack Tom | -1 |
| Ett element i stacken | 0 |
| Stack full | N-1 |
| Överflöde (element> N) | N |
Stackklass i Java
Java Collection Framework tillhandahåller en klass som heter 'Stack'. Denna Stack-klass utökar Vector-klassen och implementerar Stack-datastrukturens funktionalitet.
Nedanstående diagram visar hierarkin för Stack-klassen.
Som visas i ovanstående diagram ärver Stack-klassen vektorklassen som i sin tur implementerar gränssnittet List Interface of Collection.
Stack-klassen är en del av paketet java.util. För att inkludera Stack-klassen i programmet kan vi använda importförklaringen enligt följande.
import java.util.*; eller
import java.util.Stack; Skapa en stack i Java
När vi har importerat Stack-klassen kan vi skapa ett Stack-objekt som visas nedan:
Stack mystack = new Stack(); Vi kan också skapa en generisk typ av Stack-klassobjekt enligt följande:
Stack myStack = new Stack; Här kan data_type vara vilken giltig datatyp som helst i Java.
Till exempel ,vi kan skapa följande Stack-klassobjekt.
Stack stack_obj = new Stack(); Stack str_stack = new Stack(); Stack API-metoder i Java
Stapelklassen tillhandahåller metoder för att lägga till, ta bort och söka data i stacken. Det ger också en metod för att kontrollera om stacken är tom. Vi kommer att diskutera dessa metoder i nedanstående avsnitt.
skillnad mellan java och c ++
Stack Push-operation
Push-operationen används för att skjuta eller lägga till element i stacken. När vi väl har skapat en stackinstans kan vi använda push-operationen för att lägga till elementen av stack-objekttypen till stacken.
Följande kod används för att initiera en heltalstack med värdena.
Stack myStack = new Stack(); myStack.push(10); myStack.push(15); myStack.push(20); Den initiala stacken som erhållits som ett resultat av ovanstående kodkörning visas nedan:
Om vi utför en annan push () -åtgärd som visas nedan,
push(25); Den resulterande stacken blir:
Stack Pop-operation
Vi kan ta bort elementet från stacken med hjälp av 'pop' -operationen. Elementet som pekas av toppen för närvarande poppar från stacken.
Följande kod uppnår detta.
Stack intStack = new Stack(); intStack.push(100); intStack.push(200); int val = intStack.pop(); Den variabla valen kommer att innehålla värdet 200 eftersom det var det sista elementet som trycktes in i stacken.
Stackrepresentationen för push- och pop-operation är som följer:
Stack Peek-operation
Tittoperationen returnerar toppen av stacken utan att ta bort elementet. I ovanstående stackexempel returnerar “intStack.peek ()” 200.
Stack isEmpty Operation
Funktionen isEmpty () i Stack-klassen kontrollerar om stack-objektet är tomt. Det returnerar true om Stack inte har några element i den annars returnerar false.
Stack-sökning
Vi kan söka efter ett element i stacken med hjälp av sökningen (). Sökningen () returnerar indexet för det element som du söker efter. Detta index räknas från toppen av stacken.
Stack intStack = new Stack (); intStack.push (100); intStack.push (200); int index = inStack.search(100); //index will have the value 2.Stackstorlek
Storleken på Stack-objektet ges av java.util.Stack.size () metod. Det returnerar det totala antalet element i stacken.
I följande exempel skrivs ut stapelstorleken.
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 / Iterera stapelelement
Vi kan förklara en iterator för stacken och sedan korsa genom hela stacken med hjälp av denna iterator. På så sätt kan vi besöka och skriva ut varje stackelement en efter en.
Följande program visar hur du kan itera Stack med hjälp 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() + ' '); } } }Produktion:
Stackelement:
PUNE MUMBAI NASHIK
Stapla med Java 8
Vi kan också skriva ut eller korsa stackelementen med hjälp av Java 8-funktioner som Stream API: er, forEach och forEachRemaining-konstruktioner.
Följande program visar användningen av Java 8-konstruktioner för att korsa genom stacken.
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 + ' '); }); } } Produktion:
Stapla element med Java 8 forEach:
PUNE MUMBAI NASHIK
Stapla element med Java 8 forEachRemaining:
PUNE MUMBAI NASHIK
Stackimplementering i Java
Följande program implementerar den detaljerade stacken som visar de olika stackoperationerna.
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()); } } Produktion:
Initial stack: ()
Är stacken tom? : Sann
Stack efter push-operation: (10, 20, 30, 40)
Element dök ut: 40
Stack efter popoperation: (10, 20, 30)
Element 10 hittat vid position: 3
Är Stack tom? : falskt
hur man kör jar-filer på Windows 10
Stack till Array i Java
Stapeldatastrukturen kan konverteras till en array med 'toArray ()' -metoden i Stack-klassen.
Följande program visar denna konvertering.
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 Produktion:
Stackinnehållet: (PUNE, MUMBAI, NASHIK)
Array-innehållet:
PUNE MUMBAI NASHIK
Stackimplementering i Java med hjälp av Array
Stapeln kan implementeras med en Array. Alla stackoperationer utförs med hjälp av en array.
Nedanstående program visar stackimplementeringen med hjälp av en matris.
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(); } } Produktion:
Initial stack tom: sant
Efter Push-operation ...
Utskrift av stackelement ... ..
40 30 20 10
Objekt poppade upp: 40
Objekt poppade upp: 30
Efter popoperation ...
Utskrift av stackelement ... ..
20 10
Stackimplementering med länkad lista
Stapeln kan också implementeras med hjälp av en länkad lista precis som vi har gjort med arrays. En fördel med att använda en länkad lista för att implementera stack är att den kan växa eller krympa dynamiskt. Vi behöver inte ha en maximal storleksbegränsning som i arrays.
Följande program implementerar en länkad lista för att utföra stackoperationer.
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()); } } Produktion:
Stackelement:
1-> 3-> 5-> 7-> 9->
Stapeltopp: 1
Pop två element
Stackelement:
5-> 7-> 9->
gratis DVD-ripper för Windows 10
Ny stapeltopp: 5
Vanliga frågor
F # 1) Vad är staplar i Java?
Svar: En stack är en LIFO (Last in, First out) datastruktur för lagring av element. Stackelementen läggs till eller tas bort från stacken från ena änden som heter Top of the stack.
Tillägget av ett element till stacken görs med Push-operationen. Radering av element görs med pop-operation. I Java implementeras en stack med hjälp av Stack-klassen.
F # 2) Är Stack en samling i Java?
Svar: Ja. Stapeln är en äldre samling i Java som är tillgänglig från Collection API i Java 1.0 och framåt. Stack ärver vektorklassen i List-gränssnittet.
F # 3) Är Stack ett gränssnitt?
Svar: Interface stack är ett gränssnitt som beskriver den sista in, först ut-strukturen och används för att lagra tillståndet för rekursiva problem.
F # 4) Vad används stackar till?
Svar: Följande är de viktigaste applikationerna i stacken:
- Uttrycksutvärdering och konverteringar: Stack används för att konvertera uttryck till postfix, infix och prefix. Det används också för att utvärdera dessa uttryck.
- Stapeln används också för att analysera syntaxträd.
- Stapeln används för att kontrollera parenteser i ett uttryck.
- Stapeln används för att lösa backtracking-problem.
- Funktionssamtal utvärderas med hjälp av stackar.
F # 5) Vilka är fördelarna med stacken?
Svar: Variabler som lagras i stacken förstörs automatiskt när de returneras. Staplar är ett bättre val när minnet tilldelas och omplaceras. Stacks rensar också upp minnet. Bortsett från att staplar kan användas effektivt för att utvärdera uttryck och analysera uttrycken.
Slutsats
Detta kompletterar vår handledning om staplar i Java. Stack-klassen är en del av samlings-API: et och stöder push-, pop-, peek- och sökoperationer. Elementen läggs till eller tas bort till / från stacken endast i ena änden. Detta slut kallas toppen av stacken.
I den här handledningen har vi sett alla metoder som stöds av stackklassen. Vi har också implementerat stacken med arrays och länkade listor.
Vi fortsätter med andra insamlingskurser i våra efterföljande handledning.
=> Läs igenom Easy Java Training Series
Rekommenderad läsning
- Java Reflection Tutorial med exempel
- Java Scanner-klasshandledning med exempel
- Vad är en Java HashTable - HashTable Implementation & Exempel
- Vad är Java Vector | Java Vector Class Tutorial med exempel
- Java Array Class Tutorial - java.util.Arrays Class med exempel
- Java Basics: Java Syntax, Java Class och Core Java Concepts
- LinkedHashMap I Java - LinkedHashMap Exempel och implementering
- Java SWING-handledning: Container, komponenter och händelsehantering
