Java Cadre de collecte fournit une classe Stack qui modélise et implémente un Le diagramme ci-dessous montre le hiérarchie de la classe Stack :
La classe en prend en charge un constructeur par défaut Empiler() qui sert à créer une pile vide .
Déclaration:
public class Stack extends Vector>
Toutes les interfaces implémentées :
- Sérialisable : Il s'agit d'une interface de marqueur que les classes doivent implémenter si elles doivent être sérialisées et désérialisées.
- Clonable : Il s'agit d'une interface en Java qui doit être implémentée par une classe pour permettre le clonage de ses objets.
- Itérable : Cette interface représente une collection d'objets itérables, c'est-à-dire qui peuvent être itérés.
- Collection: Une collection représente un groupe d'objets appelés éléments. L'interface Collection est utilisée pour transmettre des collections d'objets où une généralité maximale est souhaitée.
- Liste: L'interface List fournit un moyen de stocker la collection commandée. Il s'agit d'une interface enfant de Collection.
- Accès aléatoire: Il s'agit d'une interface de marqueur utilisée par les implémentations de List pour indiquer qu'elles prennent en charge un accès aléatoire rapide (généralement à temps constant).
Comment créer une pile ?
Afin de créer une pile, nous devons importer java.util.stack package et utilisez le constructeur Stack() de cette classe. L'exemple ci-dessous crée une pile vide.
Pile pile = new Stack();
Ici E est le type d’objet.
Exemple:
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>);> >}> }> |
mvc-java
>
>
Sortir:
Pop Operation: 4 3 2 1 0 Element on stack top: 4 Element is found at position: 3 Element not found>
Effectuer diverses opérations sur la classe Stack
1. Ajout d'éléments : Afin d'ajouter un élément à la pile, nous pouvons utiliser le méthode push() . Ce pousser() L’opération place l’élément en haut de la pile.
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);> >}> }> |
>
>
Sortir:
[4, All, Geeks] [Geeks, For, Geeks]>
2. Accéder à l'élément : Pour récupérer ou récupérer le premier élément de la Stack ou l'élément présent en haut de la Stack, on peut utiliser coup d'oeil() méthode. L'élément récupéré n'est pas supprimé ou supprimé de la pile.
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);> >}> }> |
cours de mathématiques Java
>
>
Sortir:
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. Suppression d'éléments : Pour extraire un élément de la pile, nous pouvons utiliser le populaire() méthode. L'élément est retiré du haut de la pile et en est supprimé.
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);> >}> }> |
>
>
Sortir:
Initial Stack: [10, 15, 30, 20, 5] Popped element: 5 Popped element: 20 Stack after pop operation [10, 15, 30]>
Exemple
En Java, la classe Stack est une sous-classe de la classe Vector et représente une pile d'objets dernier entré, premier sorti (LIFO). Il étend la classe Vector pour permettre une implémentation facile de la structure de données de la pile.
Voici un exemple de la façon dont vous pouvez utiliser la classe Stack en 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());> >}> >}> }> |
Diana Mary Blacker
>
>Sortir
4 3 2 1>
Dans cet exemple, nous importons d’abord la classe Stack du package java.util. Nous créons ensuite un nouvel objet Stack appelé stack en utilisant le constructeur par défaut. Nous plaçons quatre entiers sur la pile en utilisant la méthode push(). Nous extrayons ensuite les éléments de la pile en utilisant la méthode pop() dans une boucle while. La méthode isEmpty() est utilisée pour vérifier si la pile est vide avant de tenter de faire apparaître un élément.
Ce code crée une pile d'entiers et place 4 entiers sur la pile dans l'ordre 1 -> 2 -> 3 -> 4. Nous extrayons ensuite les éléments de la pile un par un à l'aide de la méthode pop(), qui supprime et renvoie le élément supérieur de la pile. Étant donné que la pile suit un ordre du dernier entré, premier sorti (LIFO), les éléments sont extraits dans l'ordre inverse de l'insertion, ce qui donne le résultat indiqué ci-dessus.
La classe Stack fournit plusieurs autres méthodes pour manipuler la pile, telles que peek() pour récupérer l'élément supérieur sans le supprimer, search() pour rechercher un élément dans la pile et renvoyer sa position, et size() pour renvoyer la position actuelle. taille de la pile. La classe Stack fournit également plusieurs constructeurs permettant de créer une pile avec une capacité initiale spécifiée ou en copiant une pile existante.
Méthodes dans la classe Stack
| MÉTHODE | DESCRIPTION |
|---|---|
| vide() | Il renvoie vrai si rien ne se trouve en haut de la pile. Sinon, renvoie false. |
| coup d'oeil() | Renvoie l'élément en haut de la pile, mais ne le supprime pas. |
| populaire() | Supprime et renvoie l'élément supérieur de la pile. Une « EmptyStackException » Une exception est levée si nous appelons pop() lorsque la pile invoquante est vide. |
| push (élément objet) | Pousse un élément en haut de la pile. |
| recherche (élément objet) | Il détermine si un objet existe dans la pile. Si l'élément est trouvé, Il renvoie la position de l'élément depuis le haut de la pile. Sinon, il renvoie -1. |
Méthodes héritées de la classe java.util.Vector
| MÉTHODE | DESCRIPTION |
|---|---|
| ajouter (objet obj) | Ajoute l'élément spécifié à la fin de ce vecteur. |
| ajouter (index int, objet obj) | Insère l'élément spécifié à la position spécifiée dans ce vecteur. |
| ajouterTout(Collection c) | Ajoute tous les éléments de la collection spécifiée à la fin de ce vecteur, dans l’ordre dans lequel ils sont renvoyés par l’itérateur de la collection spécifié. |
| addAll (int index, Collection c) | Insère tous les éléments de la collection spécifiée dans ce vecteur à la position spécifiée. |
| addElement (Objet o) | Ajoute le composant spécifié à la fin de ce vecteur, augmentant sa taille de un. |
| capacité() | Renvoie la capacité actuelle de ce vecteur. |
| clair() | Supprime tous les éléments de ce vecteur. |
| cloner() | Renvoie un clone de ce vecteur. |
| contient (Objet o) | Renvoie vrai si ce vecteur contient l'élément spécifié. |
| contientTout(Collection c) | Renvoie vrai si ce vecteur contient tous les éléments de la collection spécifiée. |
| copyInto (Objet [] tableau) | Copie les composants de ce vecteur dans le tableau spécifié. |
| elementAt (index int) | Renvoie le composant à l'index spécifié. |
| éléments() | Renvoie une énumération des composantes de ce vecteur. |
| assurerCapacité(int minCapacity) | Augmente la capacité de ce vecteur, si nécessaire, pour garantir qu'il puisse contenir au moins le nombre de composants spécifié par l'argument de capacité minimale. |
| équivaut à() | Compare l'objet spécifié avec ce vecteur pour l'égalité. |
| premierÉlément() | Renvoie le premier composant (l'élément à l'index 0) de ce vecteur. |
| obtenir (index int) | Renvoie l'élément à la position spécifiée dans ce vecteur. |
| code de hachage() | Renvoie la valeur du code de hachage pour ce vecteur. |
| indexDe(Objet o) | Renvoie l'index de la première occurrence de l'élément spécifié dans ce vecteur, ou -1 si ce vecteur ne contient pas l'élément. sélection de plusieurs tables SQL |
| indexOf (Objet o, index int) | Renvoie l'index de la première occurrence de l'élément spécifié dans ce vecteur, en recherchant vers l'avant à partir de l'index, ou renvoie -1 si l'élément n'est pas trouvé. |
| insertElementAt (Objet o, index int) | Insère l'objet spécifié en tant que composant dans ce vecteur à l'index spécifié. |
| est vide() | Teste si ce vecteur n’a pas de composants. |
| itérateur() | Renvoie un itérateur sur les éléments de cette liste dans le bon ordre. |
| dernierÉlément() | Renvoie la dernière composante du vecteur. |
| dernierIndexOf(Objet o) | Renvoie l'index de la dernière occurrence de l'élément spécifié dans ce vecteur, ou -1 Si ce vecteur ne contient pas l'élément. |
| lastIndexOf (Objet o, index int) | Renvoie l'index de la dernière occurrence de l'élément spécifié dans ce vecteur, recherche en arrière à partir de l'index, ou renvoie -1 si l'élément n'est pas trouvé. |
| listItérateur() | Renvoie un itérateur de liste sur les éléments de cette liste (dans le bon ordre). |
| listItérateur (index int) | Renvoie un itérateur de liste sur les éléments de cette liste (dans le bon ordre), en commençant à la position spécifiée dans la liste. |
| supprimer (index int) | Supprime l'élément à la position spécifiée dans ce vecteur. |
| supprimer (Objet o) | Supprime la première occurrence de l'élément spécifié dans ce vecteur. Si le vecteur ne contient pas l'élément, il reste inchangé. |
| supprimerTout(Collection c) | Supprime de ce vecteur tous ses éléments contenus dans la collection spécifiée. |
| supprimerAllElements() | Supprime tous les composants de ce vecteur et définit sa taille sur zéro. |
| RemoveElement (Objet o) | Supprime la première occurrence (indexée la plus basse) de l'argument de ce vecteur. |
| RemoveElementAt (index int) | Supprime le composant à l'index spécifié. |
| RemoveRange (int fromIndex, int toIndex) | Supprime de cette liste tous les éléments dont l'index est compris entre fromIndex, inclus, et toIndex, exclusif. |
| retenirTout(Collection c) | Conserve uniquement les éléments de ce vecteur contenus dans la collection spécifiée. |
| set (index int, objet o) | Remplace l'élément à la position spécifiée dans ce vecteur par l'élément spécifié. |
| setElementAt (Objet o, index int) | Définit le composant à l'index spécifié de ce vecteur comme étant l'objet spécifié. |
| setSize(int nouvelleTaille) | Définit la taille de ce vecteur. |
| taille() | Renvoie le nombre de composants dans ce vecteur. |
| sous-Liste (int fromIndex, int toIndex) | Renvoie une vue de la partie de cette liste entre fromIndex, inclus, et toIndex, exclusif. |
| versArray() | Renvoie un tableau contenant tous les éléments de ce vecteur dans le bon ordre. |
| toArray(Objet []tableau) | Renvoie un tableau contenant tous les éléments de ce vecteur dans le bon ordre ; le temps d'exécution Le type du tableau renvoyé est celui du tableau spécifié. |
| àChaîne() | Renvoie une représentation sous forme de chaîne de ce vecteur, contenant la représentation sous forme de chaîne de chaque élément. |
| trimToSize() | Réduit la capacité de ce vecteur à sa taille actuelle. |
Privilégier l'utilisation de De quoi sur pile - :
La classe Stack en Java est une classe héritée et hérite de Vecteur en Java . Il s'agit d'une classe thread-safe et implique donc une surcharge lorsque nous n'avons pas besoin de sécurité des threads. Il est recommandé d'utiliser TableauDeque pour l'implémentation de la pile car il est plus efficace dans un environnement monothread.
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());> >}> }> |
>
>
Sortir:
B B>
Une raison supplémentaire d'utiliser Deque sur Stack est que Deque a la possibilité d'utiliser des flux convertis en liste tout en conservant le concept LIFO appliqué, contrairement à Stack.
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(); } }> |
>
>Sortir
Using Stack - 1 2 Using Deque - 2 1>