Java Samlingsram tillhandahåller en Stack-klass som modellerar och implementerar en Diagrammet nedan visar hierarkin för Stack-klassen :
Klassen stödjer en standardkonstruktör Stack() som är van vid skapa en tom stack .
Deklaration:
public class Stack extends Vector>
Alla implementerade gränssnitt:
- Serialiserbar: Det är ett markörgränssnitt som klasser måste implementera om de ska serialiseras och deserialiseras.
- Klonbar: Detta är ett gränssnitt i Java som måste implementeras av en klass för att dess objekt ska kunna klonas.
- Iterable: Det här gränssnittet representerar en samling objekt som är itererbar - vilket innebär att de kan itereras.
- Samling: En samling representerar en grupp av objekt som kallas dess element. Samlingsgränssnittet används för att föra runt samlingar av objekt där maximal allmänhet önskas.
- Lista: Listgränssnittet tillhandahåller ett sätt att lagra den beställda samlingen. Det är ett barngränssnitt för Collection.
- Slumpmässig tillgång: Detta är ett markörgränssnitt som används av listimplementeringar för att indikera att de stöder snabb (vanligtvis konstant tid) slumpmässig åtkomst.
Hur skapar man en stack?
För att skapa en stack måste vi importera java.util.stack paket och använd Stack()-konstruktorn för den här klassen. Exemplet nedan skapar en tom stack.
Stack stack = ny stack();
Här är E typen av objekt.
Exempel:
Java
// Java code for stack implementation> import> java.io.*;> import> java.util.*;> class> Test> {> >// Pushing element on the top of the stack> >static> void> stack_push(Stack stack)> >{> >for>(>int> i =>0>; i <>5>; i++)> >{> >stack.push(i);> >}> >}> > >// Popping element from the top of the stack> >static> void> stack_pop(Stack stack)> >{> >System.out.println(>'Pop Operation:'>);> >for>(>int> i =>0>; i <>5>; i++)> >{> >Integer y = (Integer) stack.pop();> >System.out.println(y);> >}> >}> >// Displaying element on the top of the stack> >static> void> stack_peek(Stack stack)> >{> >Integer element = (Integer) stack.peek();> >System.out.println(>'Element on stack top: '> + element);> >}> > >// Searching element in the stack> >static> void> stack_search(Stack stack,>int> element)> >{> >Integer pos = (Integer) stack.search(element);> >if>(pos == ->1>)> >System.out.println(>'Element not found'>);> >else> >System.out.println(>'Element is found at position: '> + pos);> >}> >public> static> void> main (String[] args)> >{> >Stack stack =>new> Stack();> >stack_push(stack);> >stack_pop(stack);> >stack_push(stack);> >stack_peek(stack);> >stack_search(stack,>2>);> >stack_search(stack,>6>);> >}> }> |
lista sorterad java
>
>
Produktion:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Utföra olika operationer på Stack-klassen
1. Lägga till element: För att lägga till ett element till stacken kan vi använda push() metod . Detta skjuta på() operation placera elementet överst i stapeln.
Java
// Java program to add the> // elements in the stack> import> java.io.*;> import> java.util.*;> class> StackDemo {> > >// Main Method> >public> static> void> main(String[] args)> >{> >// Default initialization of Stack> >Stack stack1 =>new> Stack();> >// Initialization of Stack> >// using Generics> >Stack stack2 =>new> Stack();> >// pushing the elements> >stack1.push(>'4'>);> >stack1.push(>'All'>);> >stack1.push(>'Geeks'>);> >stack2.push(>'Geeks'>);> >stack2.push(>'For'>);> >stack2.push(>'Geeks'>);> >// Printing the Stack Elements> >System.out.println(stack1);> >System.out.println(stack2);> >}> }> |
>
>
Produktion:
[4, All, Geeks] [Geeks, For, Geeks]>
2. Åtkomst till elementet: För att hämta eller hämta det första elementet i stacken eller elementet som finns överst i stacken, kan vi använda titt() metod. Elementet som hämtas tas inte bort eller tas bort från stapeln.
Java
// Java program to demonstrate the accessing> // of the elements from the stack> import> java.util.*;> import> java.io.*;> public> class> StackDemo {> >// Main Method> >public> static> void> main(String args[])> >{> >// Creating an empty Stack> >Stack stack =>new> Stack();> >// Use push() to add elements into the Stack> >stack.push(>'Welcome'>);> >stack.push(>'To'>);> >stack.push(>'Geeks'>);> >stack.push(>'For'>);> >stack.push(>'Geeks'>);> >// Displaying the Stack> >System.out.println(>'Initial Stack: '> + stack);> >// Fetching the element at the head of the Stack> >System.out.println(>'The element at the top of the'> >+>' stack is: '> + stack.peek());> >// Displaying the Stack after the Operation> >System.out.println(>'Final Stack: '> + stack);> >}> }> |
länkad lista java
>
>
Produktion:
Initial Stack: [Welcome, To, Geeks, For, Geeks] The element at the top of the stack is: Geeks Final Stack: [Welcome, To, Geeks, For, Geeks]>
3. Ta bort element: För att poppa ett element från stacken kan vi använda pop() metod. Elementet fälls från toppen av stapeln och tas bort från densamma.
Java
// Java program to demonstrate the removing> // of the elements from the stack> import> java.util.*;> import> java.io.*;> public> class> StackDemo {> >public> static> void> main(String args[])> >{> >// Creating an empty Stack> >Stack stack =>new> Stack();> >// Use add() method to add elements> >stack.push(>10>);> >stack.push(>15>);> >stack.push(>30>);> >stack.push(>20>);> >stack.push(>5>);> >// Displaying the Stack> >System.out.println(>'Initial Stack: '> + stack);> >// Removing elements using pop() method> >System.out.println(>'Popped element: '> >+ stack.pop());> >System.out.println(>'Popped element: '> >+ stack.pop());> >// Displaying the Stack after pop operation> >System.out.println(>'Stack after pop operation '> >+ stack);> >}> }> |
>
>
Produktion:
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30]>
Exempel
I Java är Stack-klassen en underklass till Vector-klassen och representerar en stack av objekt som sist-in-först-ut (LIFO). Den utökar Vector-klassen för att möjliggöra enkel implementering av stackdatastrukturen.
Här är ett exempel på hur du kan använda Stack-klassen i Java:
Java
import> java.util.Stack;> public> class> StackExample {> >public> static> void> main(String[] args) {> >// Create a new stack> >Stack stack =>new> Stack();> >// Push elements onto the stack> >stack.push(>1>);> >stack.push(>2>);> >stack.push(>3>);> >stack.push(>4>);> >// Pop elements from the stack> >while>(!stack.isEmpty()) {> >System.out.println(stack.pop());> >}> >}> }> |
sortera arraylistan i java
>
>Produktion
4 3 2 1>
I det här exemplet importerar vi först Stack-klassen från paketet java.util. Vi skapar sedan ett nytt stackobjekt som kallas stack med standardkonstruktorn. Vi skjuter fyra heltal till stacken med hjälp av push()-metoden. Vi poppar sedan elementen från stacken med metoden pop() inuti en while-loop. Metoden isEmpty() används för att kontrollera om stacken är tom innan du försöker poppa ett element.
Den här koden skapar en stack med heltal och skjuter in 4 heltal till stacken i ordningen 1 -> 2 -> 3 -> 4. Vi poppar sedan element från stacken ett efter ett med metoden pop() som tar bort och returnerar översta delen av stapeln. Eftersom stacken följer en sist-in-först-ut-ordning (LIFO), poppas elementen i omvänd ordningsföljd av insättning, vilket resulterar i utdata som visas ovan.
Klassen Stack tillhandahåller flera andra metoder för att manipulera stacken, till exempel peek() för att hämta det översta elementet utan att ta bort det, search() för att söka efter ett element i stacken och returnera dess position, och size() för att returnera den aktuella stapelns storlek. Klassen Stack tillhandahåller också flera konstruktörer för att skapa en stack med en specificerad initial kapacitet eller genom att kopiera en befintlig stack.
Metoder i Stack Class
| METOD | BESKRIVNING |
|---|---|
| tömma() | Det returnerar sant om ingenting finns på toppen av stapeln. Annars returnerar falskt. |
| titt() | Returnerar elementet på toppen av stapeln, men tar inte bort det. |
| pop() | Tar bort och returnerar det översta elementet i stapeln. Ett 'EmptyStackException' Ett undantag skapas om vi anropar pop() när den anropande stacken är tom. |
| push(Objektelement) | Trycker ett element på toppen av stapeln. |
| sök(Objektelement) | Det avgör om ett objekt finns i stacken. Om elementet hittas, Det returnerar elementets position från toppen av stapeln. Annars ger det -1. |
Metoder som ärvts från klassen java.util.Vector
| METOD | BESKRIVNING |
|---|---|
| add(Object obj) | Lägger till det angivna elementet i slutet av denna vektor. |
| add(int index, Object obj) | Infogar det angivna elementet på den angivna positionen i denna vektor. |
| addAll(Samling c) | Lägger till alla element i den angivna samlingen i slutet av denna vektor, i den ordning som de returneras av den angivna samlingens Iterator. |
| addAll(int index, samling c) | Infogar alla element i den angivna samlingen i denna vektor på den angivna positionen. |
| addElement(Object o) | Lägger till den angivna komponenten i slutet av denna vektor och ökar dess storlek med en. |
| kapacitet() | Returnerar den aktuella kapaciteten för denna vektor. |
| klar() | Tar bort alla element från denna vektor. |
| klona() | Returnerar en klon av denna vektor. |
| innehåller(Objekt o) | Returnerar sant om denna vektor innehåller det angivna elementet. |
| innehåller alla (samling c) | Returnerar sant om denna vektor innehåller alla element i den angivna samlingen. |
| copyInto(Objekt []array) | Kopierar komponenterna i denna vektor till den angivna arrayen. |
| elementAt(int index) | Returnerar komponenten vid det angivna indexet. |
| elements() | Returnerar en uppräkning av komponenterna i denna vektor. |
| sureCapacity(int minCapacity) | Ökar kapaciteten för denna vektor, om nödvändigt, för att säkerställa att den kan hålla åtminstone antalet komponenter som anges av argumentet för minimumkapacitet. |
| lika() | Jämför det angivna objektet med denna vektor för jämlikhet. |
| firstElement() | Returnerar den första komponenten (objektet vid index 0) i denna vektor. |
| get(int index) | Returnerar elementet vid den angivna positionen i denna vektor. |
| hash-kod() | Returnerar hashkodvärdet för denna vektor. |
| indexOf(Objekt o) | Returnerar indexet för den första förekomsten av det angivna elementet i denna vektor, eller -1 om denna vektor inte innehåller elementet. |
| indexOf(Objekt o, int index) | Returnerar indexet för den första förekomsten av det angivna elementet i denna vektor, söker framåt från indexet, eller returnerar -1 om elementet inte hittas. |
| insertElementAt(Objekt o, int index) | Infogar det angivna objektet som en komponent i denna vektor vid det angivna indexet. |
| är tom() | Testar om denna vektor inte har några komponenter. |
| iterator() | Returnerar en iterator över elementen i den här listan i rätt ordning. |
| lastElement() | Returnerar den sista komponenten i vektorn. |
| lastIndexOf(Objekt o) | Returnerar indexet för den senaste förekomsten av det angivna elementet i denna vektor, eller -1 Om denna vektor inte innehåller elementet. fizzbuzz java |
| lastIndexOf(Objekt o, int index) | Returnerar indexet för den senaste förekomsten av det angivna elementet i denna vektor, söker bakåt från indexet, eller returnerar -1 om elementet inte hittas. |
| listIterator() | Returnerar en listiterator över elementen i den här listan (i rätt ordning). |
| listIterator(int index) | Returnerar en listiterator över elementen i den här listan (i rätt ordning), börjar på den angivna positionen i listan. |
| remove(int index) | Tar bort elementet på den angivna positionen i denna vektor. |
| ta bort(Objekt o) | Tar bort den första förekomsten av det angivna elementet i denna vektor. Om vektorn inte innehåller elementet är det oförändrat. |
| removeAll(Collection c) | Tar bort från denna vektor alla dess element som finns i den angivna samlingen. |
| removeAllElements() | Tar bort alla komponenter från denna vektor och ställer in dess storlek till noll. |
| removeElement(Object o) | Tar bort den första (lägst indexerade) förekomsten av argumentet från denna vektor. |
| removeElementAt(int index) | Tar bort komponenten vid det angivna indexet. |
| removeRange(int fromIndex, int toIndex) | Tar bort från den här listan alla element vars index är mellan fromIndex, inklusive, och toIndex, exklusiv. |
| retainAll(Samling c) | Behåller endast de element i denna vektor som finns i den angivna samlingen. |
| set(int index, Objekt o) | Ersätter elementet på den angivna positionen i denna vektor med det angivna elementet. |
| setElementAt(Objekt o, int index) | Ställer in komponenten vid det angivna indexet för denna vektor som det angivna objektet. |
| setSize(int newSize) | Ställer in storleken på denna vektor. |
| storlek() | Returnerar antalet komponenter i denna vektor. |
| subList(int fromIndex, int toIndex) | Returnerar en vy av delen av denna lista mellan fromIndex, inklusive, och toIndex, exklusiv. |
| toArray() | Returnerar en array som innehåller alla element i denna vektor i rätt ordning. |
| toArray(Objekt []array) | Returnerar en array som innehåller alla element i denna vektor i rätt ordning; körtiden typ av den returnerade matrisen är den för den angivna matrisen. |
| att stränga() | Returnerar en strängrepresentation av denna vektor, som innehåller strängrepresentationen för varje element. |
| trimToSize() | Trimmar kapaciteten för denna vektor till att vara vektorns nuvarande storlek. |
Prioritera användningen av Om vad över stack -:
Stackklassen i Java är en äldre klass och ärver från Vektor i Java . Det är en gängsäker klass och innebär därför overhead när vi inte behöver gängsäkerhet. Det rekommenderas att använda ArrayDeque för stackimplementering eftersom det är mer effektivt i en entrådig miljö.
Java
// A Java Program to show implementation> // of Stack using ArrayDeque> import> java.util.*;> class> GFG {> >public> static> void> main (String[] args) {> >Deque stack =>new> ArrayDeque();> >stack.push(>'A'>);> >stack.push(>'B'>);> >System.out.println(stack.peek());> >System.out.println(stack.pop());> >}> }> |
>
>
Produktion:
B B>
Ytterligare en anledning att använda Deque över Stack är att Deque har möjligheten att använda strömmar som konverterar till lista med att behålla LIFO-konceptet tillämpat medan Stack inte gör det.
Java
import> java.util.*;> import> java.util.stream.Collectors;> class> GFG {> >public> static> void> main (String[] args) {> > >Stack stack =>new> Stack();> >Deque deque =>new> ArrayDeque();> >stack.push(>1>);>//1 is the top> >deque.push(>1>);>//1 is the top> >stack.push(>2>);>//2 is the top> >deque.push(>2>);>//2 is the top> >List list1 = stack.stream().collect(Collectors.toList());>//[1,2]> >System.out.println(>'Using Stack -'>);> >for>(>int> i =>0>; i System.out.print(list1.get(i) + ' ' ); } System.out.println(); List list2 = deque.stream().collect(Collectors.toList());//[2,1] System.out.println('Using Deque -'); for(int i = 0; i System.out.print(list2.get(i) + ' ' ); } System.out.println(); } }> |
>
>Produktion
Using Stack - 1 2 Using Deque - 2 1>