Java Innsamlingsramme gir en Stack-klasse som modellerer og implementerer en Diagrammet nedenfor viser hierarki av Stack-klassen :
Klassen støtter en standard konstruktør Stable() som er vant til lage en tom stabel .
Erklæring:
public class Stack extends Vector>
Alle implementerte grensesnitt:
- Serialiserbar: Det er et markørgrensesnitt som klasser må implementere hvis de skal serialiseres og deserialiseres.
- Klonbar: Dette er et grensesnitt i Java som må implementeres av en klasse for at objektene skal kunne klones.
- Iterable: Dette grensesnittet representerer en samling av gjenstander som kan itereres - noe som betyr at de kan itereres.
- Samling: En samling representerer en gruppe objekter kjent som dens elementer. Samling-grensesnittet brukes til å sende rundt samlinger av objekter der maksimal generalitet er ønsket.
- Liste: Liste-grensesnittet gir en måte å lagre den bestilte samlingen på. Det er et barnegrensesnitt til Collection.
- Tilfeldig tilgang: Dette er et markørgrensesnitt som brukes av listeimplementeringer for å indikere at de støtter rask (vanligvis konstant tid) tilfeldig tilgang.
Hvordan lage en stabel?
For å lage en stabel må vi importere java.util.stack pakke og bruk Stack()-konstruktøren for denne klassen. Eksempelet nedenfor lager en tom stabel.
Stabel stabel = ny stabel();
Her er E typen objekt.
Eksempel:
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>);> >}> }> |
np.histogram
>
>
Produksjon:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Utføre ulike operasjoner på Stack-klassen
1. Legge til elementer: For å legge til et element i stabelen, kan vi bruke push() metode . Dette trykk() operasjon plasser elementet på toppen av stabelen.
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);> >}> }> |
>
>
Produksjon:
[4, All, Geeks] [Geeks, For, Geeks]>
2. Få tilgang til elementet: For å hente eller hente det første elementet i stabelen eller elementet som er på toppen av stabelen, kan vi bruke kikke() metode. Elementet som hentes blir ikke slettet eller fjernet fra stabelen.
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);> >}> }> |
pandas pivot
>
>
Produksjon:
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. Fjerning av elementer: For å hente et element fra stabelen, kan vi bruke pop() metode. Elementet sprettes fra toppen av stabelen og fjernes fra det samme.
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);> >}> }> |
>
>
Produksjon:
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30]>
Eksempel
I Java er Stack-klassen en underklasse av Vector-klassen og representerer en sist-inn-først-ut (LIFO) stabel med objekter. Den utvider Vector-klassen for å tillate enkel implementering av stabeldatastrukturen.
Her er et eksempel på hvordan du kan bruke 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());> >}> >}> }> |
>
>Produksjon
4 3 2 1>
I dette eksemplet importerer vi først Stack-klassen fra java.util-pakken. Vi lager deretter et nytt stabelobjekt kalt stack ved å bruke standardkonstruktøren. Vi skyver fire heltall på stabelen ved å bruke push()-metoden. Vi popper deretter elementene fra stabelen ved å bruke pop()-metoden inne i en while-løkke. Metoden isEmpty() brukes til å sjekke om stabelen er tom før du forsøker å åpne et element.
Denne koden lager en stabel med heltall og skyver 4 heltall inn på stabelen i rekkefølgen 1 -> 2 -> 3 -> 4. Deretter popper vi elementer fra stabelen en etter en ved å bruke pop()-metoden, som fjerner og returnerer toppelementet i stabelen. Siden stabelen følger en sist-inn-først-ut-rekkefølge (LIFO), blir elementene poppet i motsatt rekkefølge av innsetting, noe som resulterer i utgangen vist ovenfor.
Stack-klassen gir flere andre metoder for å manipulere stabelen, for eksempel peek() for å hente toppelementet uten å fjerne det, search() for å søke etter et element i stabelen og returnere dets posisjon, og size() for å returnere gjeldende element. størrelsen på stabelen. Stack-klassen gir også flere konstruktører for å lage en stabel med en spesifisert startkapasitet eller ved å kopiere en eksisterende stabel.
Metoder i Stack Class
| METODE | BESKRIVELSE |
|---|---|
| tømme() | Det returnerer sant hvis ingenting er på toppen av stabelen. Ellers returnerer falsk. |
| kikke() | Returnerer elementet på toppen av stabelen, men fjerner det ikke. |
| pop() | Fjerner og returnerer det øverste elementet i stabelen. Et «EmptyStackException» Et unntak blir kastet hvis vi kaller pop() når den påkallende stabelen er tom. |
| push(objektelement) | Skyver et element på toppen av stabelen. |
| søk (objektelement) .tostring java | Den avgjør om det finnes et objekt i stabelen. Hvis elementet blir funnet, Den returnerer posisjonen til elementet fra toppen av stabelen. Ellers gir den -1. |
Metoder arvet fra klassen java.util.Vector
| METODE | BESKRIVELSE |
|---|---|
| add(Object obj) | Legger til det spesifiserte elementet til slutten av denne vektoren. |
| add(int index, Object obj) | Setter inn det spesifiserte elementet på den angitte posisjonen i denne vektoren. |
| addAll(Samling c) | Legger til alle elementene i den angitte samlingen til slutten av denne vektoren, i den rekkefølgen de returneres av den angitte samlingens iterator. |
| addAll(int index, samling c) | Setter inn alle elementene i den angitte samlingen i denne vektoren på den angitte posisjonen. |
| addElement(Object o) | Legger til den angitte komponenten på slutten av denne vektoren, og øker størrelsen med én. |
| kapasitet() | Returnerer gjeldende kapasitet til denne vektoren. |
| klar() | Fjerner alle elementene fra denne vektoren. |
| klone() | Returnerer en klon av denne vektoren. |
| inneholder(Objekt o) | Returnerer sann hvis denne vektoren inneholder det angitte elementet. |
| inneholder Alle (Samling c) | Returnerer sann hvis denne vektoren inneholder alle elementene i den angitte samlingen. |
| copyInto(Objekt []array) | Kopierer komponentene til denne vektoren inn i den angitte matrisen. |
| elementAt(int indeks) | Returnerer komponenten ved den angitte indeksen. |
| elementer() | Returnerer en oppregning av komponentene i denne vektoren. |
| sikreCapacity(int minCapacity) | Øker kapasiteten til denne vektoren, om nødvendig, for å sikre at den kan holde minst antallet komponenter spesifisert av minimumskapasitetsargumentet. |
| er lik() | Sammenligner det spesifiserte objektet med denne vektoren for likhet. |
| firstElement() | Returnerer den første komponenten (elementet ved indeks 0) av denne vektoren. |
| get (int indeks) | Returnerer elementet på den angitte posisjonen i denne vektoren. |
| hashkode() | Returnerer hash-kodeverdien for denne vektoren. |
| indeksOf(Objekt o) | Returnerer indeksen for den første forekomsten av det angitte elementet i denne vektoren, eller -1 hvis denne vektoren ikke inneholder elementet. |
| indexOf(Objekt o, int indeks) | Returnerer indeksen for den første forekomsten av det spesifiserte elementet i denne vektoren, søker fremover fra indeksen, eller returnerer -1 hvis elementet ikke blir funnet. |
| insertElementAt(Objekt o, int indeks) | Setter inn det angitte objektet som en komponent i denne vektoren ved den angitte indeksen. |
| er tom() | Tester om denne vektoren ikke har noen komponenter. |
| iterator() | Returnerer en iterator over elementene i denne listen i riktig rekkefølge. |
| lastElement() | Returnerer den siste komponenten i vektoren. |
| lastIndexOf(Objekt o) | Returnerer indeksen for siste forekomst av det angitte elementet i denne vektoren, eller -1 Hvis denne vektoren ikke inneholder elementet. |
| lastIndexOf(Objekt o, int indeks) | Returnerer indeksen for siste forekomst av det spesifiserte elementet i denne vektoren, søker bakover fra indeksen, eller returnerer -1 hvis elementet ikke blir funnet. |
| listIterator() | Returnerer en listeiterator over elementene i denne listen (i riktig rekkefølge). |
| listIterator(int index) | Returnerer en listeiterator over elementene i denne listen (i riktig rekkefølge), starter på den angitte posisjonen i listen. |
| remove(int index) | Fjerner elementet på den angitte posisjonen i denne vektoren. |
| fjern (Objekt o) | Fjerner den første forekomsten av det spesifiserte elementet i denne vektoren. Hvis vektoren ikke inneholder elementet, er den uendret. |
| removeAll(Samling c) | Fjerner fra denne vektoren alle dens elementer som finnes i den angitte samlingen. |
| removeAllElements() | Fjerner alle komponenter fra denne vektoren og setter størrelsen til null. |
| removeElement(Object o) | Fjerner den første (laveste indekserte) forekomsten av argumentet fra denne vektoren. |
| removeElementAt(int index) | Sletter komponenten ved den angitte indeksen. |
| removeRange(int fromIndex, int toIndex) | Fjerner fra denne listen alle elementene hvis indeks er mellom fromIndex, inklusive, og toIndex, exclusive. |
| retainAll(Samling c) | Beholder bare elementene i denne vektoren som finnes i den angitte samlingen. |
| sett(int indeks, objekt o) | Erstatter elementet på den angitte posisjonen i denne vektoren med det spesifiserte elementet. |
| setElementAt(Objekt o, int indeks) | Setter komponenten ved den angitte indeksen til denne vektoren til å være det spesifiserte objektet. |
| setSize(int newSize) | Angir størrelsen på denne vektoren. |
| størrelse() | Returnerer antall komponenter i denne vektoren. |
| subList(int fromIndex, int toIndex) | Returnerer en visning av delen av denne listen mellom fromIndex, inklusive, og toIndex, exclusive. |
| toArray() | Returnerer en matrise som inneholder alle elementene i denne vektoren i riktig rekkefølge. |
| toArray(Objekt []array) | Returnerer en matrise som inneholder alle elementene i denne vektoren i riktig rekkefølge; kjøretiden typen for den returnerte matrisen er den for den angitte matrisen. |
| toString() | Returnerer en strengrepresentasjon av denne vektoren, som inneholder strengrepresentasjonen av hvert element. |
| trimToSize() | Trimmer kapasiteten til denne vektoren til å være vektorens nåværende størrelse. |
Prioriter bruk av Om hva over Stack -:
Stack-klassen i Java er en eldre klasse og arver fra Vektor i Java . Det er en trådsikker klasse og involverer derfor overhead når vi ikke trenger trådsikkerhet. Det anbefales å bruke ArrayDeque for stackimplementering da det er mer effektivt i et enkelt-tråds miljø.
abstrakt klasse
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());> >}> }> |
>
>
Produksjon:
B B>
En annen grunn til å bruke Deque over Stack er at Deque har muligheten til å bruke strømmer som konverteres til liste med å beholde LIFO-konseptet brukt mens Stack ikke gjø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(); } }> |
>
>Produksjon
Using Stack - 1 2 Using Deque - 2 1>