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

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

[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]

J'ai suivi vos conseils et bien avancé.

voilà ma classe ListeDoublementChainee:

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
public class ListeDoublementChainee<E> implements Liste<E> {
 
    /**
     * Maillon de la liste doublement chaînée
     */
    private Maillon maillon;
 
    /**
     * Initialise le premier maillon avec la valeur passé en argument
     * @param element le premier maillon de la liste
     */
    public ListeDoublementChainee(E element) {
        maillon = new Maillon(element);
    }
 
    /**
     * Permet de reculer d'un élément dans la liste
     */
    private void precedent() {
        if (maillon.getPrecedent()!=null) {
            maillon.setElement(maillon.getPrecedent());
        }
    }
 
    /**
     * Permet d'avancer d'un élément dans la liste
     */
    public void suivant() {
        if (maillon.getSuivant()!=null) {
            maillon.setElement(maillon.getSuivant());            
        }
    }
 
    /**
     * Permet de se positionner sur le premier élément de la liste
     */
    public void premierElement() {
        while (maillon.getPrecedent() != null) {
            precedent();
        }
    }
 
    /**
     * Ajoute l'élément en tête de liste
     * @param aAjouter l'élément à ajouter
     */
    public void ajoutEnTete(E aAjouter) {
        // création du nouveau chainon avec sa valeur aAjouter
        Maillon<E> nouveauMaillon = 
            new Maillon<E>(aAjouter,maillon,null);
        // on se repositionne sur l'élément du début
        precedent();
        // precedent de l'élément courant prend la valeur du nouveau chainon
        maillon.setSuivant(nouveauMaillon);
    }
 
    /**
     * 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
        Maillon<E> nouveauMaillon = 
            new Maillon<E>(aAjouter,null,maillon);
        // precedent de l'élément courant prend la valeur du nouveau chainon
        maillon.setPrecedent(nouveauMaillon);
        // on se repositionne sur l'élément du début
        precedent();
    }
}

et ma classe Maillon:

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
83
84
85
86
87
88
89
90
public class Maillon<E> {
 
    /**
     * Elément précédent initial par défaut
     */
    final static Maillon PRECEDENT_DEFAUT = null;
 
    /**
     * Elément suivant initial par défaut
     */
    final static Maillon SUIVANT_DEFAUT = null;
 
    /**
     * Element de la liste doublement chaînée 
     */
    private Object element;
 
    /**
     * Référence vers l'élément précédent
     */
    private Maillon<E> precedent;
 
    /**
     * Référence vers l'élément suivant
     */
    private Maillon<E> suivant;
 
    /**
     * Initialise un maillon comme premier et dernier de la chaîne
     * => precedent = null
     * => suivant = null
     */
    public Maillon(E elem) {
        this(elem, PRECEDENT_DEFAUT, SUIVANT_DEFAUT);
    }
 
    /**
     * Initialise un maillon avec les paramètres passés
     * @param prec la référence vers le maillon précédent
     * @param suiv la référence vers le maillon suivant
     */
    public Maillon(E elem, Maillon<E> prec, Maillon<E> suiv) {
        element = elem;
        precedent = prec;
        suivant = suiv;
    }
 
    /**
     * @return element
     */
    public Object getElement() {
        return element;
    }
 
    /**
     * @param element l'élément à modifier
     */
    public void setElement(Object element) {
        this.element = element;
    }
 
    /**
     * @return precedent
     */
    public Maillon<E> getPrecedent() {
        return precedent;
    }
 
    /**
     * @param precedent l'élément à modifier
     */
    public void setPrecedent(Maillon<E> precedent) {
        this.precedent = precedent;
    }
 
    /**
     * @return suivant
     */
    public Maillon<E> getSuivant() {
        return suivant;
    }
 
    /**
     * @param suivant l'élément à modifier
     */
    public void setSuivant(Maillon<E> suivant) {
        this.suivant = suivant;
    }
 
}

Mais le problème subsiste lorsque je fais celà:

Code :

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

Maillon<E> nouveauMaillon = new Maillon<E>(aAjouter,null,maillon);

Voila mon programme de test:

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
public class TestListeDoublementChainee {
 
    /**
     * Programme de test
     * @param args, non utilisé
     */
    public static void main(String[] args) {
 
        /* création d'une liste doublement chaînée de Personnes */
        Enseignant prof = new Enseignant("Champ", "Jean-Jacques", "15/08/1949", "Mathematiques");
        Enseignant prof2 = new Enseignant("Einstein", "Albert", "14/03/1879", "18/04/1955", "Physique");
 
        ListeDoublementChainee<Personne> listeDouble = 
            new ListeDoublementChainee<Personne>(prof);
 
        String element = listeDouble.getElem();
        System.out.println(element);
 
        listeDouble.ajouter(prof2, 0);
 
        element = listeDouble.getElem();
        System.out.println(element);
 
        listeDouble.suivant();
 
        element = listeDouble.getElem();
        System.out.println(element);
 
    }
}

Et voilà ce que j'obtiens en console:

Champ Jean-Jacques, ne le 15/08/1949, => Mathematiques
lpd2i.collection.Maillon@4fe5e2c3
hello
lpd2i.collection.Maillon@4fe5e2c3

Donc l'affichage de mon nouvel élément ne se fait pas (ou bien mon nouvel élément n'a pas été initialisé comme il faut) et d'autre part je ne peut pas passer à l'élément suivant.

Merci de votre aide car j'en chie (ça se voit je pense )

[Alkhan]

En effet, tu as du mal !

Il est normal que cela ne marche pas !
Tu ne fais pas attention a ce que tu écris :

Code :

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

1
2
3
4
5
6
7
 
// classe ListeDoublementChainee
	private void precedent() {
		if (maillon.getPrecedent() != null) {
			maillon.setElement(maillon.getPrecedent());
		}
	}

Tu remplace la valeur du noeud par le maillon précédent et tu fais la même chose sur le suivant !

Autre exemple :

Code :

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

1
2
3
4
5
6
7
8
9
 
	public void ajoutEnTete(E aAjouter) {
		// création du nouveau chainon avec sa valeur aAjouter
		Maillon<E> nouveauMaillon = new Maillon<E>(aAjouter, maillon, null);
		// on se repositionne sur l'élément du début
		precedent();
		// precedent de l'élément courant prend la valeur du nouveau chainon
		maillon.setSuivant(nouveauMaillon);
	}

l'appel a precedent sert a quoi ?
si ta liste est une boucle tu as besoin de connaitre le 1er élément
si ta liste n'est pas une boucle alors il te faut une référence sur le 1er et le dernier

Lorsque tu ajoutes un nouveau noeud au debut (par exemple) tu dis que le se nouveau noeud à comme suivant le noeud qui était jusqu'a présent le 1er.
Mais il faut aussi dire à l'ancien premier noeud que sont précédent est maintenant le nouveau noeud.

J'ajouterais que c'est à ta liste de savoir sur quel noeud tu es lors d'un parcours (suivant et précédent).

[Benduroy]

Merci de votre aide.
J'arrive enfin à "naviguer" entre mes maillons.

En effet mon code de parcours n'avait ni queue ni tête.
Je l'ai remplacé par:

Code :

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

1
2
3
4
5
6
7
8
    /**
     * Permet d'avancer d'un élément dans la liste
     */
    public void suivant() {
        if (maillon.getSuivant()!=null) {
            maillon = maillon.getSuivant();        
        }
    }

[Alkhan]

Attention car maillon.getSuivant() va exploser lorsque tu n'auras aucun élément dans la liste. il faut impérativement vérifier que maillon n'est pas null.

[herve91]

Attention car maillon.getSuivant() va exploser lorsque tu n'auras aucun élément dans la liste. il faut impérativement vérifier que maillon n'est pas null.

C'est pour cette raison que j'avais précisé qu'une liste circulaire évitait de tester les références à null. A la création de la liste il faut alors créer le maillon représentant la liste vide :

Code :

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

1
2
3
Maillon tete = new Maillon(null, null, null);
tete.precedent = tete;
tete.suivant = tete;

[Alkhan]

oui je suis d'accord avec toi herve91 !
je n'ai pas insisté sur la chose vu qu'il a déjà un peu de mal pour le reste, je me suis dit qu'une liste qui boucle sera une difficulté supplémentaire pour lui.

[herve91]

En effet, je suis d'accord, commençons par une liste linéaire.