Java Indsamlingsramme giver en Stack-klasse, der modellerer og implementerer en Nedenstående diagram viser hierarki af Stack-klassen :
Klassen støtter en standard konstruktør Stak() som er vant til oprette en tom stak .
Erklæring:
public class Stack extends Vector>
Alle implementerede grænseflader:
- Serialiserbar: Det er en markørgrænseflade, som klasser skal implementere, hvis de skal serialiseres og deserialiseres.
- Kan klones: Dette er en grænseflade i Java, som skal implementeres af en klasse for at tillade dens objekter at blive klonet.
- Iterable: Denne grænseflade repræsenterer en samling af objekter, som kan itereres - hvilket betyder, at de kan itereres.
- Kollektion: En samling repræsenterer en gruppe af objekter kendt som dens elementer. Samling-grænsefladen bruges til at videregive samlinger af objekter, hvor maksimal generalitet ønskes.
- Liste: Listegrænsefladen giver mulighed for at gemme den bestilte samling. Det er en børnegrænseflade til Collection.
- Tilfældig adgang: Dette er en markørgrænseflade, der bruges af listeimplementeringer til at indikere, at de understøtter hurtig (generelt konstant tid) tilfældig adgang.
Hvordan opretter man en stak?
For at oprette en stak skal vi importere java.util.stack pakke og brug Stack()-konstruktøren af denne klasse. Nedenstående eksempel opretter en tom stak.
Stak stak = ny stak();
Her er E typen af 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>);> >}> }> |
char + int i java
>
>
Produktion:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Udførelse af forskellige operationer på Stack-klassen
1. Tilføjelse af elementer: For at tilføje et element til stakken, kan vi bruge push() metode . Det her skubbe() betjening placer elementet i toppen af stakken.
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. Adgang til elementet: For at hente eller hente det første element i stakken eller det element, der findes øverst i stakken, kan vi bruge kig() metode. Det hentede element bliver ikke slettet eller fjernet fra stakken.
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 omdrejningspunkt
>
>
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. Fjernelse af elementer: For at få et element ud af stakken kan vi bruge pop() metode. Elementet er poppet fra toppen af stakken og fjernes fra 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);> >}> }> |
>
>
Produktion:
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 af Vector-klassen og repræsenterer en sidst-i-først-ud (LIFO) stak af objekter. Det udvider Vector-klassen for at muliggøre nem implementering af stakdatastrukturen.
Her er et eksempel på, hvordan du kan bruge 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());> >}> >}> }> |
>
>Produktion
4 3 2 1>
I dette eksempel importerer vi først Stack-klassen fra pakken java.util. Vi opretter derefter et nyt stakobjekt kaldet stack ved hjælp af standardkonstruktøren. Vi skubber fire heltal på stakken ved hjælp af push()-metoden. Vi popper derefter elementerne fra stakken ved hjælp af pop()-metoden inde i en while-løkke. Metoden isEmpty() bruges til at kontrollere, om stakken er tom, før du forsøger at pop et element.
Denne kode opretter en stak af heltal og skubber 4 heltal ind på stakken i rækkefølgen 1 -> 2 -> 3 -> 4. Derefter popper vi elementer fra stakken et efter et ved hjælp af pop()-metoden, som fjerner og returnerer øverste element af stakken. Da stakken følger en last-in-first-out (LIFO) rækkefølge, bliver elementerne poppet i omvendt rækkefølge af indsættelse, hvilket resulterer i output vist ovenfor.
Stack-klassen giver flere andre metoder til at manipulere stakken, såsom peek() for at hente det øverste element uden at fjerne det, search() for at søge efter et element i stakken og returnere dets position, og size() for at returnere det aktuelle element. stakkens størrelse. Stack-klassen giver også flere konstruktører til at skabe en stak med en specificeret startkapacitet eller ved at kopiere en eksisterende stak.
Metoder i Stack Class
| METODE | BESKRIVELSE |
|---|---|
| tom() | Det returnerer sandt, hvis intet er på toppen af stakken. Ellers returnerer falsk. |
| kig() | Returnerer elementet på toppen af stakken, men fjerner det ikke. |
| pop() | Fjerner og returnerer det øverste element af stakken. En 'EmptyStackException' En undtagelse bliver kastet, hvis vi kalder pop(), når den påkaldende stak er tom. |
| push(objektelement) | Skubber et element på toppen af stakken. |
| søg (objektelement) arraylist sorteret | Det bestemmer, om der findes et objekt i stakken. Hvis elementet findes, Det returnerer elementets position fra toppen af stakken. Ellers returnerer det -1. |
Metoder nedarvet fra klassen java.util.Vector
| METODE | BESKRIVELSE |
|---|---|
| add(Object obj) | Tilføjer det angivne element til slutningen af denne vektor. |
| add(int index, Object obj) | Indsætter det angivne element på den angivne position i denne vektor. |
| addAll(Samling c) | Føjer alle elementerne i den angivne samling til slutningen af denne vektor, i den rækkefølge, de returneres af den angivne samlings iterator. |
| addAll(int index, Collection c) | Indsætter alle elementerne i den angivne samling i denne vektor på den angivne position. |
| addElement(Object o) | Tilføjer den angivne komponent til slutningen af denne vektor og øger dens størrelse med én. |
| kapacitet() | Returnerer den aktuelle kapacitet af denne vektor. |
| klar() | Fjerner alle elementer fra denne vektor. |
| klone() | Returnerer en klon af denne vektor. |
| indeholder (Objekt o) | Returnerer sand, hvis denne vektor indeholder det angivne element. |
| indeholder Alle (Samling c) | Returnerer sand, hvis denne vektor indeholder alle elementerne i den angivne samling. |
| copyInto(Objekt []array) | Kopierer komponenterne i denne vektor til det angivne array. |
| elementAt(int indeks) | Returnerer komponenten ved det angivne indeks. |
| elementer() | Returnerer en opregning af komponenterne i denne vektor. |
| sikreCapacity(int minCapacity) | Øger kapaciteten af denne vektor, hvis det er nødvendigt, for at sikre, at den kan holde mindst antallet af komponenter specificeret af minimumskapacitetsargumentet. |
| lige med() | Sammenligner det specificerede objekt med denne vektor for lighed. |
| firstElement() | Returnerer den første komponent (elementet ved indeks 0) af denne vektor. |
| get (int indeks) | Returnerer elementet på den angivne position i denne vektor. |
| hashCode() | Returnerer hash-kodeværdien for denne vektor. |
| indexOf(Objekt o) | Returnerer indekset for den første forekomst af det angivne element i denne vektor, eller -1 hvis denne vektor ikke indeholder elementet. |
| indexOf(Objekt o, int indeks) | Returnerer indekset for den første forekomst af det angivne element i denne vektor, søger fremad fra indekset, eller returnerer -1, hvis elementet ikke findes. |
| insertElementAt(Objekt o, int indeks) | Indsætter det angivne objekt som en komponent i denne vektor ved det angivne indeks. |
| er tom() | Tester om denne vektor ikke har nogen komponenter. |
| iterator() | Returnerer en iterator over elementerne i denne liste i korrekt rækkefølge. |
| lastElement() | Returnerer den sidste komponent af vektoren. |
| lastIndexOf(Objekt o) | Returnerer indekset for den sidste forekomst af det angivne element i denne vektor, eller -1 Hvis denne vektor ikke indeholder elementet. |
| lastIndexOf(Objekt o, int indeks) | Returnerer indekset for den sidste forekomst af det angivne element i denne vektor, søger baglæns fra indekset, eller returnerer -1, hvis elementet ikke findes. |
| listIterator() | Returnerer en listeiterator over elementerne i denne liste (i korrekt rækkefølge). |
| listIterator(int index) | Returnerer en listeiterator over elementerne i denne liste (i korrekt rækkefølge), starter på den angivne position på listen. |
| fjern (int indeks) | Fjerner elementet på den angivne position i denne vektor. |
| fjern (Objekt o) | Fjerner den første forekomst af det angivne element i denne vektor. Hvis vektoren ikke indeholder elementet, er den uændret. |
| removeAll(Samling c) | Fjerner fra denne vektor alle dens elementer, der er indeholdt i den angivne samling. |
| removeAllElements() | Fjerner alle komponenter fra denne vektor og sætter dens størrelse til nul. |
| fjernElement(Objekt o) | Fjerner den første (laveste indekserede) forekomst af argumentet fra denne vektor. |
| removeElementAt(int index) | Sletter komponenten ved det angivne indeks. |
| removeRange(int fromIndex, int toIndex) | Fjerner fra denne liste alle de elementer, hvis indeks er mellem fromIndex, inklusive, og toIndex, exclusive. |
| retainAll(Samling c) | Beholder kun de elementer i denne vektor, der er indeholdt i den angivne samling. |
| sæt(int indeks, objekt o) | Erstatter elementet på den angivne position i denne vektor med det angivne element. |
| setElementAt(Objekt o, int indeks) | Indstiller komponenten ved det angivne indeks for denne vektor til at være det angivne objekt. |
| setSize(int newSize) | Indstiller størrelsen af denne vektor. |
| størrelse() | Returnerer antallet af komponenter i denne vektor. |
| subList(int fromIndex, int toIndex) | Returnerer en visning af delen af denne liste mellem fromIndex, inklusive, og toIndex, exclusive. |
| toArray() | Returnerer et array, der indeholder alle elementerne i denne vektor i den korrekte rækkefølge. |
| toArray(Objekt []array) | Returnerer et array, der indeholder alle elementerne i denne vektor i den korrekte rækkefølge; køretiden typen af det returnerede array er det for det angivne array. |
| toString() | Returnerer en strengrepræsentation af denne vektor, der indeholder strengrepræsentationen af hvert element. |
| trimToSize() | Trimmer kapaciteten af denne vektor til at være vektorens aktuelle størrelse. |
Prioriter brug af Om hvad over stak -:
Stack-klassen i Java er en ældre klasse og arver fra Vektor i Java . Det er en gevindsikker klasse og involverer derfor overhead, når vi ikke har brug for gevindsikkerhed. Det anbefales at bruge ArrayDeque til stakimplementering, da det er mere effektivt i et enkelttrådsmiljø.
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());> >}> }> |
>
>
Produktion:
B B>
Endnu en grund til at bruge Deque over Stack er, at Deque har muligheden for at bruge streams, der konverteres til liste med at holde LIFO-konceptet anvendt, mens Stack ikke 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>