Discussion :

[Benduroy]

Bonjour à tous,

Je suis actuellement étudiant en licence professionnelle informatique à Rodez, et pour les vacances on nous a donné un exercice pour remettre tout le monde à niveaux. Il s'agit de réinventer la roue et de développer la LinkedList de java. Enfin les principales méthodes comme l'ajout, la suppression etc.

Je trime depuis hier, et là j'en suis à la méthode qui ajoute en queue de liste.
Mon problème vient de l'utilisation de l'objet courant this lorsque je fais ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
ListeDoublementChainee<E> nouveauChainon = 
            new ListeDoublementChainee<E>(aAjouter,null,this);

je vais créer un nouvel objet mais je ne pourrais jamais passer à l'élément suivant (toujours à null).

Voilà le code entier du début de ma classe:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
public class ListeDoublementChainee<E> implements Liste<E> {
 
    /**
     * Elément précédent initial par défaut
     */
    private final static ListeDoublementChainee PRECEDENT_DEFAUT = null;
 
    /**
     * Elément suivant initial par défaut
     */
    private final static ListeDoublementChainee SUIVANT_DEFAUT = null;
 
    /**
     * Element de la liste doublement chaînée 
     */
    private static Object element;
 
    /**
     * Référence vers l'élément précédent
     */
    private ListeDoublementChainee<E> precedent;
 
    /**
     * Référence vers l'élément suivant
     */
    private ListeDoublementChainee<E> suivant;
 
    /**
     * Initialise la liste doublement chaînée comme premier et dernier
     * maillon de la chaîne
     * => precedent = null
     * => suivant = null
     * Initialise le premier élément à null
     */
    public ListeDoublementChainee(E elem) {
        this(elem, PRECEDENT_DEFAUT, SUIVANT_DEFAUT);
    }
 
    private ListeDoublementChainee(E elem, ListeDoublementChainee<E> prec, 
                                  ListeDoublementChainee<E> suiv) {
        element = elem;
        precedent = prec;
        suivant = suiv;
    }
 
    /**
     * Permet de reculer d'un élément dans la liste
     */
    private void precedent() {
        if (precedent!=null) element = precedent;
    }
 
    /**
     * Permet d'avancer d'un élément dans la liste
     */
    public void suivant() {
        if (suivant!=null) element = suivant;            
    }
 
    /**
     * Permet de se positionner sur le premier élément de la liste
     */
    public void premierElement() {
        while (precedent != null) {
            precedent();
        }
    }
 
    /**
     * Ajoute l'élément en queue de liste
     * @param aAjouter l'élément à ajouter
     */
    public void ajoutEnQueue(E aAjouter) {
        // création du nouveau chainon avec sa valeur aAjouter
        ListeDoublementChainee<E> nouveauChainon = 
            new ListeDoublementChainee<E>(aAjouter,null,this);
        // on se repositionne sur l'élément du début
        suivant();
        // precedent de l'élément courant prend la valeur du nouveau chainon
        precedent = nouveauChainon;
    }
}

Voilà j'espère avoir été clair avec mon probème.

Merci d'avance!

[Alkhan]

bonjour,

Je pense que tu t'y prend mal, tu utilise ta classe liste (ListeDoublementChainee) pour créer les nœuds de la chaîne !

Résonne plus objet, la liste c'est un objet et elle est composé de nœuds, chaque nœud connais le nœud suivant, le nœud précédent et bien sur la valeur du nœud.

[Alkhan]

je ferais un petite précision par rapport a ta question, il se trouve que la linkedList est une boucle. Donc, lorsque tu as un élément dans la liste, le suivant et le précédent c'est lui même

Bon courage

[herve91]

Il faut que tu fasses apparaître ce qu'est un maillon dans ta liste : un maillon est constitué d'une valeur, d'un maillon précédent et d'un maillon suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
static class Maillon<E> {
	E element;
	Maillon<E> previous;
	Maillon<E> next;

A partir de là, les méthodes de List travaillent sur des instances de Maillon<E>, après c'est un choix de rendre la liste circulaire ou non (la première option permettant de s'affranchir des tests de "pointeur" à null)

[Benduroy]

Voilà herve91, j'ai essayé de suivre tes conseils. Mais lorsque je veux intervenir sur les champs precedent et suivant j'ai une erreur: Cannot make a static reference to the non-static field Maillon.precedent.
C'est une erreur que j'ai souvent et que je ne comprend jamais.

Voilà mon code à présent:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class ListeDoublementChainee<E> implements Liste<E> {
 
    static class Maillon<E> {
        /**
         * Elément précédent initial par défaut
         */
        final static ListeDoublementChainee PRECEDENT_DEFAUT = null;
 
        /**
         * Elément suivant initial par défaut
         */
        final static ListeDoublementChainee SUIVANT_DEFAUT = null;
 
        /**
         * Element de la liste doublement chaînée 
         */
        static Object element;
 
        /**
         * Référence vers l'élément précédent
         */
        ListeDoublementChainee<E> precedent;
 
        /**
         * Référence vers l'élément suivant
         */
        ListeDoublementChainee<E> suivant;
 
        /**
         * Initialise la liste doublement chaînée comme premier et dernier
         * maillon de la chaîne
         * => precedent = null
         * => suivant = null
         * Initialise le premier élément à null
         */
        public Maillon(E elem) {
            this(elem, PRECEDENT_DEFAUT, SUIVANT_DEFAUT);
        }
 
        private Maillon(E elem, ListeDoublementChainee<E> prec, 
                                      ListeDoublementChainee<E> suiv) {
            element = elem;
            precedent = prec;
            suivant = suiv;
        }
    }
 
    /**
     * Permet de reculer d'un élément dans la liste
     */
    private void precedent() {
        if (Maillon.precedent!=null) Maillon.element = Maillon.precedent;
    }
}

Suis-je sur la bonne voie?

[Alkhan]

Suis-je sur la bonne voie?

pas encore !

Mais lorsque je veux intervenir sur les champs precedent et suivant j'ai une erreur: Cannot make a static reference to the non-static field Maillon.precedent.

Cela signifie que tu essayes d'accéder à la variable "precedent" de la classe "Maillon" sans qu'il y est une instance de la classe "Maillon" et vu que la variable "precedent" n'est pas une variable static, cela provoque l'erreur.

Regarde bien, ce que l'on écrit lorsque l'on répond à tes questions !
herve91 t'as donné un morceau de ce que peut être un maillon.
suivant et precedent sont de type maillon et non pas de type ListeDoublementChainee.
Maillon n'est que la classe à partir de laquelle tu dois créer des instances de maillon à chaque ajout dans la liste.

[Benduroy]

Je ne suis pas sur de comprendre. Tu me conseilles de faire deux classes en fait. Une classe Maillon et une classe Liste qui manipulerait mes maillons c'est bien ça?