Guide du Débutant pour la Classe Pile Java

Introduction

Salut les futurs développeurs Java ! Aujourd'hui, nous allons plonger dans le monde fascinant de la classe Pile Java. Ne vous inquiétez pas si vous n'avez jamais écrit une ligne de code avant – je serai votre guide amical lors de ce voyage passionnant.

Imaginez que vous organisez vos livres. Vous les empilez les uns sur les autres. Le dernier livre que vous mettez sur la pile est le premier que vous prenez quand vous en avez besoin. C'est exactement comment une Pile fonctionne en Java ! C'est une structure de données "Dernier-Entré-Premier-Sorti" (LIFO), et c'est extrêmement utile en programmation.

Déclaration de Classe

Commençons par les bases. En Java, la classe Pile fait partie du package java.util. Pour l'utiliser, vous devez l'importer comme suit :

import java.util.Stack;

La classe Pile étend la classe Vector et implémente des interfaces telles que List, Collection, Iterable, Cloneable et Serializable. Ne vous inquiétez pas si ces termes vous semblent un langage étranger maintenant – nous y arriverons !

Constructeurs de Classe

La classe Pile n'a qu'un seul constructeur :

Stack<E> pile = new Stack<E>();

Ici, 'E' est un espace réservé pour le type d'éléments que vous souhaitez stocker dans votre pile. Cela pourrait être Integer, String ou n'importe quel autre type d'objet. Par exemple :

Stack<Integer> pileDeNombres = new Stack<Integer>();
Stack<String> pileDeLivres = new Stack<String>();

Dans la première ligne, nous créons une pile qui contiendra des entiers. Dans la seconde, nous faisons une pile pour des chaînes de caractères – parfait pour notre analogie de la pile de livres !

Méthodes de Classe

Maintenant, examinons les principales méthodes de la classe Pile. Je les présente dans un tableau pour une référence facile :

Méthode	Description
push(E item)	Ajoute un élément en haut de la pile
pop()	Supprime et renvoie l'élément en haut de la pile
peek()	Renvoie l'élément en haut sans le supprimer
empty()	Vérifie si la pile est vide
search(Object o)	Recherche un objet et renvoie sa position

Analysons ces méthodes avec quelques exemples :

push(E item)

Stack<String> pileDeLivres = new Stack<String>();
pileDeLivres.push("Java pour Débutants");
pileDeLivres.push("Structures de Données en Java");

Ici, nous ajoutons des livres à notre pile. "Structures de Données en Java" est maintenant au-dessus de "Java pour Débutants".

pop()

String livreDuHaut = pileDeLivres.pop();
System.out.println("Livre supprimé : " + livreDuHaut);

Cela supprime "Structures de Données en Java" du sommet de la pile et le renvoie.

peek()

String prochainLivre = pileDeLivres.peek();
System.out.println("Prochain livre à lire : " + prochainLivre);

Cela nous indique le livre du haut sans le supprimer – dans ce cas, "Java pour Débutants".

empty()

if (pileDeLivres.empty()) {
System.out.println("Plus de livres à lire !");
} else {
System.out.println("Vous avez encore des livres à lire !");
}

Cela vérifie si notre pile est vide. C'est comme vérifier si nous avons fini tous nos livres !

search(Object o)

int position = pileDeLivres.search("Java pour Débutants");
if (position != -1) {
System.out.println("Livre trouvé à la position : " + position);
} else {
System.out.println("Livre non trouvé dans la pile.");
}

Cela recherche un livre dans notre pile. Rappelez-vous, la position est comptée du haut, et l'élément du haut est à la position 1.

Méthodes Héritées

La classe Pile hérite également de méthodes de sa classe parent, Vector, et des interfaces qu'elle implémente. Quelques méthodes héritées utiles incluent :

• size(): Renvoie le nombre d'éléments dans la pile
• contains(Object o): Vérifie si un objet est dans la pile
• clear(): Supprime tous les éléments de la pile

Exemple

Mettons tout cela en pratique avec un exemple amusant. Imaginez que nous gardons la trace de notre pile de crêpes !

import java.util.Stack;

public class PileDeCrêpes {
public static void main(String[] args) {
Stack<String> crêpes = new Stack<>();

// Faire des crêpes
crêpes.push("Simple");
crêpes.push("Framboise");
crêpes.push("Chocolat");

System.out.println("Pile de crêpes : " + crêpes);

// Manger la crêpe du haut
String crêpeMangée = crêpes.pop();
System.out.println("Miam ! Je viens de manger une crêpe " + crêpeMangée + ".");

// Vérifier la prochaine crêpe
System.out.println("La prochaine crêpe est : " + crêpes.peek());

// Ajouter plus de crêpes
crêpes.push("Banane");

// Vérifier la taille de la pile
System.out.println("Nombre de crêpes restantes : " + crêpes.size());

// Rechercher une crêpe
int position = crêpes.search("Simple");
if (position != -1) {
System.out.println("La crêpe simple est à " + position + " du sommet.");
} else {
System.out.println("Plus de crêpes simples !");
}
}
}

Sortie

Lorsque vous exécutez ce code, vous verrez quelque chose comme ceci :

Pile de crêpes : [Simple, Framboise, Chocolat]
Miam ! Je viens de manger une crêpe Chocolat.
La prochaine crêpe est : Framboise
Nombre de crêpes restantes : 3
La crêpe simple est à 3 du sommet.

Et voilà ! Vous avez juste appris les bases de la classe Pile Java. Rappelez-vous, comme empiler des crêpes ou des livres, une Pile en Java suit le principe "Dernier-Entré-Premier-Sorti". C'est un outil puissant que vous trouverez utile dans de nombreux scénarios de programmation.

Continuez à pratiquer, et bientôt vous serez à empiler et à dépiler des données comme un pro ! Bon codage, et que vos piles soient toujours remplies de délicieuses crêpes... Je veux dire, de données utiles !

Credits: Image by storyset