Une Stack est une structure de données qui suit le principe Last In, First Out (LIFO). Ce 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 pouvant 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


              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 droit au but, examinons les méthodes de la classe Stack :

Méthodes

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

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 retourne l'élément situé au sommet de la pile.

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é à 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() : retourne l'élément situé au sommet de la pile sans le supprimer.

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, observation de l’élément supérieur dans la pile.

Utilisation

Considérons 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 n’êtes pas certain des boutons mentionnés, 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


              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);
    }
}

De cette manière, 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


              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.");
    }
}

Je vous rappelle que la méthode pop() supprime l’élément au sommet de la pile et le renvoie. Ainsi, en utilisant cette méthode, nous attribuons immédiatement la valeur de l’URL à la variable currentUrl.

Nous vérifions également que la pile backStack n’est pas vide ; sinon, il ne sera pas possible de revenir au lien précédent (tout simplement parce qu’il n’existera pas). Si la pile est vide, un message approprié est affiché.

De la même manière, nous implémentons la méthode pour naviguer vers la page suivante. Il suffit d’inverser les éléments dans la pile :

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édure de test de l'ensemble dans la méthode main. Utilisation de la méthode visitPage() trois fois afin de garantir que ces liens sont enregistrés dans l'historique. Ensuite, utilisation de la méthode goBack() deux fois, suivie de la méthode goForward() une fois, pour vérification du fonctionnement des méthodes écrites.

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

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;
    }
}

Il est important de noter que la classe Stack est obsolète et non recommandée pour 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 doublement terminée prenant en charge à la fois les principes FIFO et LIFO.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 4

Demandez à l'IA

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

Glissez pour afficher le menu

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

Déprécié

Exemple en 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));
    }
}

Pile

Allons droit au but, examinons les méthodes de la classe Stack :

Méthodes

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

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 retourne l'élément situé au sommet de la pile.

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);
    }
}

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

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

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, observation de l’élément supérieur dans la pile.

Utilisation

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

Fonctionnement

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

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

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);
    }
}

De cette manière, 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


              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.");
    }
}

De la même manière, nous implémentons la méthode pour naviguer vers la page suivante. Il suffit d’inverser les éléments dans la pile :

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

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;
    }
}

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 4

Structure de Données Pile en Java

Déprécié

Pile

Méthodes

Utilisation

Fonctionnement

Tests

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` ?

Structure de Données Pile en Java

Déprécié

Pile

Méthodes

Utilisation

Fonctionnement

Tests

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` ?

Structure de Données Pile en Java

Déprécié

Pile

Méthodes

Utilisation

Fonctionnement

Tests

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 ?

Structure de Données Pile en Java

Déprécié

Pile

Méthodes

Utilisation

Fonctionnement

Tests

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 ?

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

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` ?

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

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` ?