java stack tutorial stack class implementation with examples
Ce didacticiel explique ce qu'est Stack en Java, Java Stack Class, Stack API Methods, Stack Implementation using Array & Linked List à l'aide d'exemples:
Une pile est une structure de données ordonnée appartenant à Java Collection Framework. Dans cette collection, les éléments sont ajoutés et supprimés d'une seule extrémité. La fin à laquelle les éléments sont ajoutés et supprimés est appelée «Top of the Stack».
Comme l'ajout et la suppression ne sont effectués qu'à une seule extrémité, le premier élément ajouté à la pile se trouve être le dernier élément retiré de la pile. Ainsi, la pile est appelée une structure de données LIFO (Last-in, First-out).
=> Jetez un œil au guide du débutant Java ici
Ce que vous apprendrez:
- Collection Java Stack
- Conclusion
Collection Java Stack
Une représentation picturale de la pile est donnée ci-dessous.
Comme indiqué dans la séquence de représentation ci-dessus, initialement la pile est vide et le haut de la pile est défini sur -1. Ensuite, nous lançons une opération «push» qui sert à ajouter un élément à la pile.
Donc, dans la deuxième représentation, nous poussons l'élément 10. À ce stade, le haut est incrémenté. Nous poussons à nouveau l'élément 20 dans l'empilement, incrémentant ainsi le sommet en outre.
Dans la dernière représentation, on lance une opération «pop». Cette opération permet de supprimer un élément de la pile. Un élément actuellement pointé sur 'Top' est supprimé par l'opération pop.
Une structure de données de pile prend en charge les opérations suivantes:
- Pousser: Ajoute un élément à la pile. En conséquence, la valeur du sommet est incrémentée.
- Pop: Un élément est supprimé de la pile. Après l'opération pop, la valeur du sommet est décrémentée.
- Coup d'oeil: Cette opération est utilisée pour rechercher ou rechercher un élément. La valeur du haut n'est pas modifiée.
Le haut de la pile utilisé comme extrémité pour ajouter / supprimer des éléments de la pile peut également avoir différentes valeurs à un instant particulier. Si la taille de la pile est N, alors le haut de la pile aura les valeurs suivantes dans des conditions différentes selon l'état dans lequel se trouve la pile.
Statut de la pile | Top valeur |
---|---|
Pile vide | -1 |
Un élément dans la pile | 0 |
Pile pleine | N-1 |
Débordement (éléments> N) | N |
Classe de pile en Java
Java Collection Framework fournit une classe nommée «Stack». Cette classe Stack étend la classe Vector et implémente les fonctionnalités de la structure de données Stack.
Le diagramme ci-dessous montre la hiérarchie de la classe Stack.
Comme le montre le diagramme ci-dessus, la classe Stack hérite de la classe Vector qui à son tour implémente l'interface de liste de l'interface de collection.
La classe Stack fait partie du package java.util. Pour inclure la classe Stack dans le programme, nous pouvons utiliser l'instruction import comme suit.
import java.util.*;
ou
import java.util.Stack;
Créer une pile en Java
Une fois que nous importons la classe Stack, nous pouvons créer un objet Stack comme indiqué ci-dessous:
Stack mystack = new Stack();
Nous pouvons également créer un type générique d'objet de classe Stack comme suit:
Stack myStack = new Stack;
Ici, data_type peut être n'importe quel type de données valide en Java.
Par exemple ,nous pouvons créer les objets de classe Stack suivants.
Stack stack_obj = new Stack(); Stack str_stack = new Stack();
Empiler les méthodes API en Java
La classe Stack fournit des méthodes pour ajouter, supprimer et rechercher des données dans la pile. Il fournit également une méthode pour vérifier si la pile est vide. Nous discuterons de ces méthodes dans la section ci-dessous.
Opération de poussée de pile
L'opération push est utilisée pour pousser ou ajouter des éléments dans la pile. Une fois que nous avons créé une instance de pile, nous pouvons utiliser l'opération push pour ajouter les éléments du type d'objet pile à la pile.
Le morceau de code suivant est utilisé pour initialiser une pile d'entiers avec les valeurs.
Stack myStack = new Stack(); myStack.push(10); myStack.push(15); myStack.push(20);
La pile initiale obtenue à la suite de l'exécution de code ci-dessus est indiquée ci-dessous:
Si nous effectuons une autre opération push () comme indiqué ci-dessous,
push(25);
La pile résultante sera:
Opération Stack Pop
Nous pouvons supprimer l'élément de la pile en utilisant l'opération «pop». L'élément pointé par le haut actuellement est sorti de la pile.
Le morceau de code suivant y parvient.
Stack intStack = new Stack(); intStack.push(100); intStack.push(200); int val = intStack.pop();
La variable val contiendra la valeur 200 car c'était le dernier élément poussé dans la pile.
La représentation de la pile pour les opérations push et pop est la suivante:
Opération Stack Peek
L'opération peek renvoie le haut de la pile sans supprimer l'élément. Dans l'exemple de pile ci-dessus, «intStack.peek ()» renverra 200.
La pile est une opération vide
L'opération isEmpty () de la classe Stack vérifie si l'objet stack est vide. Il retourne true si la pile ne contient aucun élément, sinon renvoie false.
comment ouvrir les fichiers .bin
Opération de recherche de pile
Nous pouvons rechercher un élément sur la pile en utilisant l'opération search (). L'opération search () renvoie l'index de l'élément recherché. Cet index est compté à partir du haut de la pile.
Stack intStack = new Stack (); intStack.push (100); intStack.push (200); int index = inStack.search(100); //index will have the value 2.
Taille de la pile
La taille de l'objet Stack est donnée par le java.util.Stack.size () méthode. Il renvoie le nombre total d'éléments dans la pile.
L'exemple suivant imprime la taille de la pile.
Stack myStack = new Stack(); myStack.push(100); myStack.push(200); myStack.push(300); System.out.println('Stack size:' + myStack.size()); //Stack size: 3
Imprimer / itérer les éléments de la pile
Nous pouvons déclarer un itérateur pour la pile, puis parcourir toute la pile en utilisant cet itérateur. De cette façon, nous pouvons visiter et imprimer chaque élément de la pile un par un.
Le programme suivant montre la façon d'itérer Stack à l'aide d'un itérateur.
import java.util.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements:'); //get an iterator for the stack Iterator iterator = stack.iterator(); //traverse the stack using iterator in a loop and print each element while(iterator.hasNext()){ System.out.print(iterator.next() + ' '); } } }
Production:
Éléments de la pile:
PUNE MUMBAI NASHIK
Empiler à l'aide de Java 8
Nous pouvons également imprimer ou parcourir les éléments de la pile à l'aide de fonctionnalités Java 8 telles que les API Stream, forEach et forEachRemaining.
Le programme suivant montre l'utilisation des constructions Java 8 pour traverser la pile.
import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); System.out.println('Stack elements using Java 8 forEach:'); //get a stream for the stack Stream stream = stack.stream(); //traverse though each stream object using forEach construct of Java 8 stream.forEach((element) -> { System.out.print(element + ' '); // print element }); System.out.println('
Stack elements using Java 8 forEachRemaining:'); //define an iterator for the stack Iterator stackIterator = stack.iterator(); //use forEachRemaining construct to print each stack element stackIterator.forEachRemaining(val -> { System.out.print(val + ' '); }); } }
Production:
Empilez les éléments à l'aide de Java 8 forEach:
PUNE MUMBAI NASHIK
Empilez les éléments à l'aide de Java 8 forEachRemaining:
PUNE MUMBAI NASHIK
Implémentation de pile en Java
Le programme suivant implémente la pile détaillée démontrant les différentes opérations de pile.
import java.util.Stack; public class Main { public static void main(String a()){ //declare a stack object Stack stack = new Stack(); //print initial stack System.out.println('Initial stack : ' + stack); //isEmpty () System.out.println('Is stack Empty? : ' + stack.isEmpty()); //push () operation stack.push(10); stack.push(20); stack.push(30); stack.push(40); //print non-empty stack System.out.println('Stack after push operation: ' + stack); //pop () operation System.out.println('Element popped out:' + stack.pop()); System.out.println('Stack after Pop Operation : ' + stack); //search () operation System.out.println('Element 10 found at position: ' + stack.search(10)); System.out.println('Is Stack empty? : ' + stack.isEmpty()); } }
Production:
Pile initiale: ()
La pile est-elle vide? : vrai
Pile après opération de poussée: (10, 20, 30, 40)
Élément sorti: 40
Pile après l'opération Pop: (10, 20, 30)
Élément 10 trouvé à la position: 3
La pile est-elle vide? : faux
Empiler vers tableau en Java
La structure de données de la pile peut être convertie en un tableau à l’aide de la méthode «toArray ()» de la classe Stack.
Le programme suivant illustre cette conversion.
import java.util.*; import java.util.stream.*; public class Main { public static void main(String() args) { //declare and initialize a stack object Stack stack = new Stack(); stack.push('PUNE'); stack.push('MUMBAI'); stack.push('NASHIK'); //print the stack System.out.println('The Stack contents: ' + stack); // Create the array and use toArray() method to convert stack to array Object() strArray = stack.toArray(); //print the array System.out.println('The Array contents:'); for (int j = 0; j Production:
Le contenu de la pile: (PUNE, MUMBAI, NASHIK)
Le contenu du tableau:
PUNE MUMBAI NASHIK

Implémentation de pile en Java à l'aide de Array
La pile peut être implémentée à l'aide d'un tableau. Toutes les opérations de pile sont effectuées à l'aide d'un tableau.
Le programme ci-dessous illustre l'implémentation de Stack à l'aide d'un tableau.
import java.util.*; //Stack class class Stack { int top; //define top of stack int maxsize = 5; //max size of the stack int() stack_arry = new int(maxsize); //define array that will hold stack elements Stack(){ //stack constructor; initially top = -1 top = -1; } boolean isEmpty(){ //isEmpty () method return (top <0); } boolean push (int val){ //push () method if(top == maxsize-1) { System.out.println('Stack Overflow !!'); return false; } else { top++; stack_arry(top)=val; return true; } } boolean pop () { //pop () method if (top == -1) { System.out.println('Stack Underflow !!'); return false; } else { System.out.println('
Item popped: ' + stack_arry(top--)); return true; } } void display () { //print the stack elements System.out.println('Printing stack elements .....'); for(int i = top; i>=0;i--) { System.out.print(stack_arry(i) + ' '); } } } public class Main { public static void main(String() args) { //define a stack object Stack stck = new Stack(); System.out.println('Initial Stack Empty : ' + stck.isEmpty()); //push elements stck.push(10); stck.push(20); stck.push(30); stck.push(40); System.out.println('After Push Operation...'); //print the elements stck.display(); //pop two elements from stack stck.pop(); stck.pop(); System.out.println('After Pop Operation...'); //print the stack again stck.display(); } }
Production:
Pile initiale vide: vrai
Après l'opération Push…
Impression des éléments de la pile… ..
40 30 20 10
Point sauté: 40
Objet sauté: 30
Après l'opération Pop…
Impression des éléments de la pile… ..
20 10

Implémentation de la pile à l'aide de la liste liée
La pile peut également être implémentée en utilisant une liste chaînée, tout comme nous l'avons fait avec des tableaux. L'un des avantages de l'utilisation d'une liste chaînée pour l'implémentation de la pile est qu'elle peut augmenter ou diminuer dynamiquement. Nous n'avons pas besoin d'avoir une restriction de taille maximale comme dans les tableaux.
Le programme suivant implémente une liste chaînée pour effectuer des opérations de pile.
import static java.lang.System.exit; // Stack class using LinkedList class Stack_Linkedlist { // Define Node of LinkedList private class Node { int data; // node data Node nlink; // Node link } // top of the stack Node top; // stack class Constructor Stack_Linkedlist() { this.top = null; } // push () operation public void push(int val) { // create a new node Node temp = new Node(); // checks if the stack is full if (temp == null) { System.out.print('
Stack Overflow'); return; } // assign val to node temp.data = val; // set top of the stack to node link temp.nlink = top; // update top top = temp; } // isEmpty () operation public boolean isEmpty() { return top == null; } // peek () operation public int peek() { // check if the stack is empty if (!isEmpty()) { return top.data; } else { System.out.println('Stack is empty!'); return -1; } } // pop () operation public void pop() { // check if stack is out of elements if (top == null) { System.out.print('
Stack Underflow!!'); return; } // set top to point to next node top = (top).nlink; } //print stack contents public void display() { // check for stack underflow if (top == null) { System.out.printf('
Stack Underflow!!'); exit(1); } else { Node temp = top; System.out.println('Stack elements:'); while (temp != null) { // print node data System.out.print(temp.data + '->'); // assign temp link to temp temp = temp.nlink; } } } } public class Main { public static void main(String() args) { // Create a stack class object Stack_Linkedlist stack_obj = new Stack_Linkedlist(); // push values into the stack stack_obj.push(9); stack_obj.push(7); stack_obj.push(5); stack_obj.push(3); stack_obj.push(1); // print Stack elements stack_obj.display(); // print current stack top System.out.println('
Stack top : ' + stack_obj.peek()); // Pop elements twice System.out.println('Pop two elements'); stack_obj.pop(); stack_obj.pop(); // print Stack elements stack_obj.display(); // print new stack top System.out.println('
New Stack top:' + stack_obj.peek()); } }
Production:
Éléments de la pile:
1-> 3-> 5-> 7-> 9->
Haut de la pile: 1
Pop deux éléments
Éléments de la pile:
5-> 7-> 9->
Nouveau haut Stack: 5

Questions fréquemment posées
Q # 1) Que sont les piles en Java?
Répondre: Une pile est une structure de données LIFO (dernier entré, premier sorti) pour stocker des éléments. Les éléments de la pile sont ajoutés ou supprimés de la pile à une extrémité appelée Haut de la pile.
L'ajout d'un élément à la pile se fait à l'aide de l'opération Push. La suppression des éléments se fait à l'aide de l'opération pop. En Java, une pile est implémentée à l'aide de la classe Stack.
Q # 2) Stack est-il une collection en Java?
Répondre: Oui. La pile est une collection héritée en Java qui est disponible à partir de l'API Collection à partir de Java 1.0. Stack hérite de la classe Vector de l'interface List.
Q # 3) Stack est-il une interface?
Répondre: La pile d'interface est une interface qui décrit la structure dernier entré, premier sorti et est utilisée pour stocker l'état des problèmes récursifs.
Q # 4) À quoi servent les piles?
Réponse: Voici les principales applications de la pile:
- Évaluation des expressions et conversions: Stack est utilisé pour convertir des expressions en suffixe, infixe et préfixe. Il est également utilisé pour évaluer ces expressions.
- La pile est également utilisée pour analyser les arbres de syntaxe.
- La pile est utilisée pour vérifier les parenthèses dans une expression.
- La pile est utilisée pour résoudre les problèmes de retour en arrière.
- Les appels de fonction sont évalués à l'aide de piles.
Q # 5) Quels sont les avantages de la pile?
Répondre: Les variables stockées sur la pile sont détruites automatiquement lorsqu'elles sont renvoyées. Les piles sont un meilleur choix lorsque la mémoire est allouée et désallouée. Les piles nettoient également la mémoire. En dehors de cela, les piles peuvent être utilisées efficacement pour évaluer des expressions et analyser les expressions.
Conclusion
Ceci termine notre tutoriel sur les piles en Java. La classe Stack fait partie de l'API de collecte et prend en charge les opérations push, pop, peek et search. Les éléments sont ajoutés ou supprimés à / de la pile à une seule extrémité. Cette extrémité est appelée le haut de la pile.
que pouvez-vous faire avec c ++
Dans ce tutoriel, nous avons vu toutes les méthodes prises en charge par la classe stack. Nous avons également implémenté la pile en utilisant des tableaux et des listes liées.
Nous continuerons avec d'autres classes de collection dans nos prochains tutoriels.
=> Lisez la série de formations Easy Java
lecture recommandée
- Tutoriel de réflexion Java avec des exemples
- Tutoriel de classe de scanner Java avec des exemples
- Qu'est-ce qu'un HashTable Java - Implémentation et exemple de HashTable
- Qu'est-ce que le vecteur Java | Tutoriel de classe vectorielle Java avec des exemples
- Tutoriel sur les classes Java Array - Classe java.util.Arrays avec exemples
- Principes de base de Java: syntaxe Java, classe Java et principaux concepts Java
- LinkedHashMap en Java - Exemple et implémentation LinkedHashMap
- Tutoriel Java SWING: Conteneur, composants et gestion des événements