Le empiler est une structure de données linéaire utilisée pour stocker la collection d'objets. C'est basé sur Dernier entré, premier sorti (LIFO). Collection Java framework fournit de nombreuses interfaces et classes pour stocker la collection d’objets. L'un d'eux est le Classe de pile qui fournit différentes opérations telles que push, pop, recherche, etc.

Dans cette section, nous aborderons les Classe Java Pile , c'est méthodes, et mettre en œuvre la structure de données de la pile dans un Programme Java . Mais avant de passer à la classe Java Stack, ayez un aperçu rapide du fonctionnement de la pile.

La structure de données de la pile comporte les deux opérations les plus importantes qui sont pousser et populaire . L'opération push insère un élément dans la pile et l'opération pop supprime un élément du haut de la pile. Voyons comment ils fonctionnent sur la pile.

Poussons respectivement 20, 13, 89, 90, 11, 45, 18 dans la pile.

Supprimons (pop) 18, 45 et 11 de la pile.

Pile vide : Si la pile ne contient aucun élément, on parle de pile vide . Lorsque la pile est vide, la valeur de la variable supérieure est -1.

un million en chiffres

Lorsque nous poussons un élément dans la pile, le haut est augmenté de 1 . Dans la figure suivante,

• Appuyez sur 12, haut = 0
• Appuyez sur 6, haut = 1
• Appuyez sur 9, haut = 2

Lorsque nous retirons un élément de la pile, la valeur de top est diminué de 1 . Dans la figure suivante, nous en avons fait apparaître 9.

Le tableau suivant présente les différentes valeurs du sommet.

Classe de pile Java

En Java, Empiler est une classe qui relève du framework Collection qui étend le Vecteur classe. Il implémente également des interfaces Liste, Collection, Itérable, Clonable, Sérialisable. Il représente la pile d'objets LIFO. Avant d'utiliser la classe Stack, nous devons importer lejava.utilemballer. Classe de pile organisée dans la hiérarchie du framework Collections, comme indiqué ci-dessous.

Constructeur de classe de pile

La classe Stack contient uniquement le constructeur par défaut cela crée une pile vide.

 public Stack() 

Créer une pile

Si nous voulons créer une pile, importez d’abord lejava.utilpackage et créez un objet de la classe Stack.

 Stack stk = new Stack(); 

Ou

 Stack stk = new Stack(); 

Où type désigne le type de pile comme Integer, String, etc.

Méthodes de la classe Stack

Nous pouvons effectuer des opérations push, pop, peek et search sur la pile. La classe Java Stack fournit principalement cinq méthodes pour effectuer ces opérations. Parallèlement à cela, il fournit également toutes les méthodes de Classe de vecteur Java .

Méthode Stack Class vide ()

Le vide() méthode de la classe Stack vérifie que la pile est vide ou non. Si la pile est vide, elle renvoie vrai, sinon elle renvoie faux. On peut également utiliser la méthode isEmpty() de la classe Vector.

Syntaxe

 public boolean empty() 

Retour: La méthode renvoie vrai si la pile est vide, sinon renvoie faux.

Dans l'exemple suivant, nous avons créé une instance de la classe Stack. Après cela, nous avons invoqué la méthode empty() deux fois. La première fois qu'il revient vrai car nous n’avons poussé aucun élément dans la pile. Après cela, nous avons poussé les éléments dans la pile. Encore une fois, nous avons invoqué la méthode empty() qui renvoie FAUX car la pile n'est pas vide.

parcours d'arbre dans l'ordre

StackEmptyMethodExample.java

 import java.util.Stack; public class StackEmptyMethodExample { public static void main(String[] args) { //creating an instance of Stack class Stack stk= new Stack(); // checking stack is empty or not boolean result = stk.empty(); System.out.println('Is the stack empty? ' + result); // pushing elements into stack stk.push(78); stk.push(113); stk.push(90); stk.push(120); //prints elements of the stack System.out.println('Elements in Stack: ' + stk); result = stk.empty(); System.out.println('Is the stack empty? ' + result); } } 

Sortir:

 Is the stack empty? true Elements in Stack: [78, 113, 90, 120] Is the stack empty? false 

Méthode push() de la classe Stack

La méthode insère un élément en haut de la pile. Cela fonctionne de la même manière que la méthode addElement(item) de la classe Vector. Il passe un paramètre article à pousser dans la pile.

Syntaxe

 public E push(E item) 

Paramètre: Un élément à placer en haut de la pile.

Retour: La méthode renvoie l'argument que nous avons passé en paramètre.

Méthode pop() de la classe Stack

La méthode supprime un objet en haut de la pile et renvoie le même objet. Ça jette EmptyStackException si la pile est vide.

Syntaxe

 public E pop() 

Retour: Il renvoie un objet qui se trouve en haut de la pile.

Implémentons la pile dans un programme Java et effectuons des opérations push et pop.

StackPushPopExample.java

 import java.util.*; public class StackPushPopExample { public static void main(String args[]) { //creating an object of Stack class Stack stk = new Stack(); System.out.println('stack: ' + stk); //pushing elements into the stack pushelmnt(stk, 20); pushelmnt(stk, 13); pushelmnt(stk, 89); pushelmnt(stk, 90); pushelmnt(stk, 11); pushelmnt(stk, 45); pushelmnt(stk, 18); //popping elements from the stack popelmnt(stk); popelmnt(stk); //throws exception if the stack is empty try { popelmnt(stk); } catch (EmptyStackException e) { System.out.println('empty stack'); } } //performing push operation static void pushelmnt(Stack stk, int x) { //invoking push() method stk.push(new Integer(x)); System.out.println('push -> ' + x); //prints modified stack System.out.println('stack: ' + stk); } //performing pop operation static void popelmnt(Stack stk) { System.out.print('pop -> '); //invoking pop() method Integer x = (Integer) stk.pop(); System.out.println(x); //prints modified stack System.out.println('stack: ' + stk); } } 

Sortir:

 stack: [] push -> 20 stack: [20] push -> 13 stack: [20, 13] push -> 89 stack: [20, 13, 89] push -> 90 stack: [20, 13, 89, 90] push -> 11 stack: [20, 13, 89, 90, 11] push -> 45 stack: [20, 13, 89, 90, 11, 45] push -> 18 stack: [20, 13, 89, 90, 11, 45, 18] pop -> 18 stack: [20, 13, 89, 90, 11, 45] pop -> 45 stack: [20, 13, 89, 90, 11] pop -> 11 stack: [20, 13, 89, 90] 

Méthode peek() de la classe Stack

Il examine l'élément qui se trouve en haut de la pile. Il jette aussi EmptyStackException si la pile est vide.

Syntaxe

 public E peek() 

Retour: Il renvoie les éléments supérieurs de la pile.

Voyons un exemple de la méthode peek().

StackPeekMethodExample.java

 import java.util.Stack; public class StackPeekMethodExample { public static void main(String[] args) { Stack stk= new Stack(); // pushing elements into Stack stk.push('Apple'); stk.push('Grapes'); stk.push('Mango'); stk.push('Orange'); System.out.println('Stack: ' + stk); // Access element from the top of the stack String fruits = stk.peek(); //prints stack System.out.println('Element at top: ' + fruits); } } 

Sortir:

 Stack: [Apple, Grapes, Mango, Orange] Element at the top of the stack: Orange 

Méthode de recherche de classe Stack ()

La méthode recherche l'objet dans la pile à partir du haut. Il analyse un paramètre que nous souhaitons rechercher. Il renvoie l'emplacement de base 1 de l'objet dans la pile. L'objet le plus haut de la pile est considéré à la distance 1.

chaîne.format

Supposons que o soit un objet dans la pile que nous souhaitons rechercher. La méthode renvoie la distance depuis le haut de la pile de l'occurrence la plus proche du sommet de la pile. Il utilise équivaut à() méthode pour rechercher un objet dans la pile.

Syntaxe

 public int search(Object o) 

Paramètre: o est l'objet que l'on souhaite rechercher.

Retour: Il renvoie l'emplacement de l'objet à partir du haut de la pile. S'il renvoie -1, cela signifie que l'objet n'est pas sur la pile.

Voyons un exemple de la méthode search().

StackSearchMethodExample.java

 import java.util.Stack; public class StackSearchMethodExample { public static void main(String[] args) { Stack stk= new Stack(); //pushing elements into Stack stk.push('Mac Book'); stk.push('HP'); stk.push('DELL'); stk.push('Asus'); System.out.println('Stack: ' + stk); // Search an element int location = stk.search('HP'); System.out.println('Location of Dell: ' + location); } } 

Opérations de la pile Java

Taille de la pile

On peut également trouver la taille de la pile en utilisant la méthode size() de la classe Vector. Il renvoie le nombre total d'éléments (taille de la pile) dans la pile.

Syntaxe

 public int size() 

Voyons un exemple de la méthode size() de la classe Vector.

StackSizeExample.java

 import java.util.Stack; public class StackSizeExample { public static void main (String[] args) { Stack stk = new Stack(); stk.push(22); stk.push(33); stk.push(44); stk.push(55); stk.push(66); // Checks the Stack is empty or not boolean rslt=stk.empty(); System.out.println('Is the stack empty or not? ' +rslt); // Find the size of the Stack int x=stk.size(); System.out.println('The stack size is: '+x); } } 

Sortir:

 Is the stack empty or not? false The stack size is: 5 

Itérer les éléments

Itérer signifie récupérer les éléments de la pile. Nous pouvons récupérer des éléments de la pile en utilisant trois méthodes différentes :

• En utilisant itérateur() Méthode
• En utilisant pour chaque() Méthode
• En utilisant listItérateur() Méthode

Utilisation de la méthode itérateur()

C'est la méthode de l'interface Iterator. Il renvoie un itérateur sur les éléments de la pile. Avant d'utiliser la méthode iterator(), importez lejava.util.Itérateuremballer.

Syntaxe

 Iterator iterator() 

Effectuons une itération sur la pile.

StackIterationExample1.java

 import java.util.Iterator; import java.util.Stack; public class StackIterationExample1 { public static void main (String[] args) { //creating an object of Stack class Stack stk = new Stack(); //pushing elements into stack stk.push('BMW'); stk.push('Audi'); stk.push('Ferrari'); stk.push('Bugatti'); stk.push('Jaguar'); //iteration over the stack Iterator iterator = stk.iterator(); while(iterator.hasNext()) { Object values = iterator.next(); System.out.println(values); } } } 

Sortir:

PowerShell contre bash

 BMW Audi Ferrari Bugatti Jaguar 

Utilisation de la méthode forEach()

Java fournit une méthode forEach() pour parcourir les éléments. La méthode est définie dans le Itérable et Flux interface.

Syntaxe

 default void forEach(Consumeraction) 

Parcourons la pile en utilisant la méthode forEach().

StackIterationExample2.java

 import java.util.*; public class StackIterationExample2 { public static void main (String[] args) { //creating an instance of Stack class Stack stk = new Stack(); //pushing elements into stack stk.push(119); stk.push(203); stk.push(988); System.out.println('Iteration over the stack using forEach() Method:'); //invoking forEach() method for iteration over the stack stk.forEach(n -> { System.out.println(n); }); } } 

Sortir:

 Iteration over the stack using forEach() Method: 119 203 988 

Utilisation de la méthode listIterator()

Cette méthode renvoie un itérateur de liste sur les éléments de la liste mentionnée (dans l'ordre), en commençant à la position spécifiée dans la liste. Il parcourt la pile de haut en bas.

Syntaxe

 ListIterator listIterator(int index) 

Paramètre: La méthode analyse un paramètre nommé indice.

Retour: Cette méthode renvoie un itérateur de liste sur les éléments, dans l'ordre.

Exception: Ça jette IndexOutOfBoundsException si l'index est hors de portée.

Parcourons la pile en utilisant la méthode listIterator().

StackIterationExample3.java

 import java.util.Iterator; import java.util.ListIterator; import java.util.Stack; public class StackIterationExample3 { public static void main (String[] args) { Stack stk = new Stack(); stk.push(119); stk.push(203); stk.push(988); ListIterator ListIterator = stk.listIterator(stk.size()); System.out.println('Iteration over the Stack from top to bottom:'); while (ListIterator.hasPrevious()) { Integer avg = ListIterator.previous(); System.out.println(avg); } } } 

Sortir:

 Iteration over the Stack from top to bottom: 988 203 119