Notice: This page requires JavaScript to function properly.
Please enable JavaScript in your browser settings or update your browser.Apprendre Structure de Données Pile en Java | Section
Structures de Données Fondamentales en Java

Structure de Données Pile en Java

Glissez pour afficher le menu

Une Stack est une structure de données qui suit le principe Last In, First Out (LIFO). Le même principe s'applique à une Deque, que vous avez étudiée précédemment, et les développeurs Java recommandent d'utiliser une Deque lorsqu'une structure de données doit fonctionner selon le principe LIFO. La structure de données Stack est obsolète et non recommandée dans le développement Java moderne.

Cependant, certaines collections ne sont plus recommandées et ont été dépréciées.

Déprécié

Lorsqu'un élément est marqué comme déprécié, cela signifie que les auteurs de la bibliothèque ou du langage de programmation conseillent d'éviter son utilisation dans le nouveau code et recommandent d'adopter de nouvelles méthodes, classes ou approches susceptibles d'offrir des solutions plus sûres, plus efficaces ou plus fonctionnelles.

Un exemple est la classe Vector en Java. Ses méthodes ont été dépréciées au profit de collections plus modernes comme ArrayList et LinkedList. Si un programmeur utilise encore les méthodes de Vector, le compilateur peut émettre un avertissement indiquant que ces méthodes sont obsolètes.

Exemple en Java :

Main.java

Main.java


              
12345678910111213141516

            
package com.example;

import java.util.Vector;

public class Main {
    public static void main(String[] args) {
        Vector<String> vector = new Vector<>();

        // Adding an element (this method is deprecated)
        vector.addElement("Item");

        // Compiler warning about the deprecated method
        // Note: 'addElement(java.lang.Object)' is deprecated.
        System.out.println(vector.get(0));
    }
}

Par conséquent, il est non recommandé d'utiliser une structure de données telle que Stack, mais nous l'aborderons dans ce chapitre car il s'agit d'une structure de données intéressante utilisée, par exemple, dans la mémoire Stack en Java.

Pile

Allons à l'essentiel, examinons les méthodes de la classe Stack :

Méthodes

push(E element) : ajoute un élément au sommet de la pile.

Main.java

Main.java


              
123456789101112

            
package com.example;

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("One");
        stack.push("Two");
        System.out.println("Stack: " + stack);
    }
}

L'ajout se fait de la même manière que dans ArrayList, examinons donc immédiatement cette méthode en combinaison avec la méthode pop() :

pop() : supprime et renvoie l'élément situé au sommet de la pile.

Main.java

Main.java


              
1234567891011121314

            
package com.example;

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("One");
        stack.push("Two");
        System.out.println("Stack: " + stack);
        stack.pop();
        System.out.println("Stack after the `pop()` method: " + stack);
    }
}

Cette méthode supprime un élément au sommet de la pile. Notez que la méthode pop() retire le dernier élément ajouté de la pile. C'est précisément ainsi que fonctionne le principe LIFO.

Il est également possible de voir quel élément se trouve au sommet de la pile :

peek() : renvoie l'élément situé au sommet de la pile sans le supprimer.

Main.java

Main.java


              
123456789101112131415

            
package com.example;

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();
        stack.push("One");
        stack.push("Two");
        System.out.println("Stack: " + stack);
        String top = stack.peek();
        System.out.println("Top element of the stack: " + top);
        System.out.println("Stack after the `peek()` method: " + stack);
    }
}

Avec cette méthode, nous consultons l’élément au sommet de la pile.

Utilisation

Prenons un exemple d’utilisation de la structure de données Stack pour la navigation entre les pages dans un navigateur (ces flèches avant et arrière que vous utilisez fréquemment).

Planification de l’implémentation de l’historique du navigateur et création des méthodes pour deux boutons (goBack() et goForward()). Si vous ne savez pas de quels boutons il s’agit, il s’agit de ces boutons de navigation :

Implémentation d'une classe contenant des méthodes pour manipuler ces deux boutons à l'aide de la structure de données Stack.

Fonctionnement

Utilisation de deux piles et d'une variable String. La première pile stocke les liens parcourus en cliquant sur la flèche "retour". La seconde pile stocke les liens parcourus en cliquant sur la flèche "avant". Une variable String conserve le lien de la page actuelle.

Cette classe comporte quatre méthodes : visitPage(), goBack(), goForward() et getCurrentPage(). Présentation détaillée de chacune d'elles.

La méthode visitPage() permet de rediriger vers l'URL spécifiée en paramètre. Lors du passage à une nouvelle page, l'ancien lien est ajouté à backStack. La pile forwardStack est vidée lors de la navigation vers une nouvelle page.

Présentation de l'implémentation dans le code :

BrowserHistory.java

BrowserHistory.java


              
1234567891011121314151617181920212223242526

            
import java.util.Stack;

public class BrowserHistory {
    private Stack<String> backStack;
    private Stack<String> forwardStack;
    private String currentUrl;

    public BrowserHistory() {
        backStack = new Stack<>();
        forwardStack = new Stack<>();
        currentUrl = "https://codefinity.com/profile/my-home";
    }

    public void visitPage(String url) {
        // When visiting a new page, add the current page to the "back" stack
        backStack.push(currentUrl);

        // Reset the "forward" stack as we moved to a new page
        forwardStack.clear();

        // Set the current page to the new URL
        currentUrl = url;

        System.out.println("Visited page: " + url);
    }
}

Ainsi, il est possible de revenir à la page précédente lors de la navigation vers une nouvelle page.

Implémentation de la méthode de retour. Fonctionnement : ajout du lien actuel à forwardStack, suppression de ce lien de backStack, puis attribution à currentUrl.

Présentation de l'implémentation dans le code :

BrowserHistory.java

BrowserHistory.java


              
12345678910

            
public void goBack() {
    if (!backStack.isEmpty()) {
        // Navigate to the previous page, move from the backStack to the forwardStack
        forwardStack.push(currentUrl);
        currentUrl = backStack.pop();
        System.out.println("Went back to: " + currentUrl);
    } else {
        System.out.println("Cannot go back. Already at the beginning.");
    }
}

Il convient de rappeler que la méthode pop() supprime l’élément situé au sommet de la pile et le retourne. Ainsi, en utilisant cette méthode, la valeur de l’URL est immédiatement affectée à la variable currentUrl.

Une vérification est également effectuée pour s’assurer que la pile backStack n’est pas vide ; dans le cas contraire, il serait impossible de revenir au lien précédent (car il n’existerait tout simplement pas). Si la pile est vide, un message approprié est affiché.

De manière similaire, la méthode de navigation vers la page suivante est implémentée. Il suffit d’inverser les éléments dans la pile :

BrowserHistory.java

BrowserHistory.java


              
12345678910

            
public void goForward() {
    if (!forwardStack.isEmpty()) {
        // Navigate to the next page, move from the forwardStack to the backStack
        backStack.push(currentUrl);
        currentUrl = forwardStack.pop();
        System.out.println("Went forward to: " + currentUrl);
    } else {
        System.out.println("Cannot go forward. Already at the latest page.");
    }
}

Il ne reste plus qu'à implémenter la méthode getCurrentPage(), qui retournera simplement la valeur de currentUrl.

Tests

Ensuite, procédons aux tests de tout cela dans la méthode main. La méthode visitPage() sera utilisée trois fois afin de s'assurer que ces liens sont enregistrés dans l'historique. Ensuite, la méthode goBack() sera utilisée deux fois, suivie de la méthode goForward() une fois, afin de vérifier le fonctionnement des méthodes écrites.

Au cours de ce processus, l'état sera suivi à l'aide de la méthode getCurrentPage(). Il est possible d'exécuter le code ci-dessous et également d'essayer d'insérer plus de liens et d'utiliser différentes méthodes pour tester le fonctionnement de cette classe :

Main.java

Main.java


              
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778

            
package com.example;

import java.util.Stack;

class Main {
    public static void main(String[] args) {
        BrowserHistory browser = new BrowserHistory();

        System.out.println("Default page: " + browser.getCurrentPage());

        browser.visitPage("https://codefinity.com/courses/tracks/7dfbcd35-5cde-49d3-80f1-bf1096487903");
        browser.visitPage("https://codefinity.com/courses/v2/8204075c-f832-4cb9-88b1-4e24e74ebdcb/bb00e195-715e-477d-8927-964e6e27cf16/e66c57b4-5f36-43b2-bd3b-e1398044fcab");
        browser.visitPage("https://codefinity.com/courses/v2/8204075c-f832-4cb9-88b1-4e24e74ebdcb/bb00e195-715e-477d-8927-964e6e27cf16/1585fb29-47cd-47a6-9fb3-5b391cad24e0");

        System.out.println("Current Page after visiting 3 pages: " + browser.getCurrentPage());

        browser.goBack();
        browser.goBack();

        System.out.println("Current Page after going back 2 times: " + browser.getCurrentPage());

        browser.goForward();

        System.out.println("Current Page after going forward: " + browser.getCurrentPage());
    }
}

class BrowserHistory {
    private Stack<String> backStack;
    private Stack<String> forwardStack;
    private String currentUrl;

    public BrowserHistory() {
        backStack = new Stack<>();
        forwardStack = new Stack<>();
        currentUrl = "https://codefinity.com/profile/my-home";
    }

    public void visitPage(String url) {
        // When visiting a new page, add the current page to the "back" stack
        backStack.push(currentUrl);

        // Reset the "forward" stack as we moved to a new page
        forwardStack.clear();

        // Set the current page to the new URL
        currentUrl = url;

        System.out.println("Visited page: " + url);
    }


    public void goBack() {
        if (!backStack.isEmpty()) {
            // Navigate to the previous page, move from the backStack to the forwardStack
            forwardStack.push(currentUrl);
            currentUrl = backStack.pop();
            System.out.println("Went back to: " + currentUrl);
        } else {
            System.out.println("Cannot go back. Already at the beginning.");
        }
    }

    public void goForward() {
        if (!forwardStack.isEmpty()) {
            // Navigate to the next page, move from the forwardStack to the backStack
            backStack.push(currentUrl);
            currentUrl = forwardStack.pop();
            System.out.println("Went forward to: " + currentUrl);
        } else {
            System.out.println("Cannot go forward. Already at the latest page.");
        }
    }

    public String getCurrentPage() {
        return currentUrl;
    }
}

Rappel : la classe Stack est obsolète et non recommandée pour une utilisation dans le développement Java moderne. Il est préférable d'utiliser Deque, qui constitue une alternative plus efficace. Dans cet exemple, Stack est implémentée selon le principe LIFO, et il est également possible d'implémenter Deque, car il s'agit d'une file à double extrémité prenant en charge à la fois les principes FIFO et LIFO.

1. Quel est le principe fondamental d'une structure de données Stack ?

2. Quelle est la méthode utilisée pour ajouter un élément au sommet de la pile en Java ?

3. Laquelle des collections Java suivantes est considérée comme une alternative plus moderne à Stack ?

4. En Java, que renverra la méthode pop() d'une Stack ?

question mark

Quel est le principe fondamental d'une structure de données Stack ?

Sélectionnez la réponse correcte

question mark

Quelle est la méthode utilisée pour ajouter un élément au sommet de la pile en Java ?

Sélectionnez la réponse correcte

question mark

Laquelle des collections Java suivantes est considérée comme une alternative plus moderne à Stack ?

Sélectionnez la réponse correcte

question mark

En Java, que renverra la méthode pop() d'une Stack ?

Sélectionnez la réponse correcte

Tout était clair ?

Comment pouvons-nous l'améliorer ?

Merci pour vos commentaires !

Section 1. Chapitre 11

Demandez à l'IA

expand

Demandez à l'IA

ChatGPT

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Section 1. Chapitre 11
some-alt