Implémentation interface Iterator,Iterable

Version imprimable

12/11/2013, 20h34
small44

Implémentation interface Iterator,Iterable

Bonjour
Dand un tp on nous a demander d'implementer les deux interface Iterable et Iterator pour permettre de parcourir les maillon,mais je sais pas comment les implementer.
Avez vous une idee comment les implementer
Merci
12/11/2013, 21h08
small44

En fait je veux redefinir les methodes de ces deux interfaces pour parcourir la liste chainee que j'ai creer.
Je sais qu'il existe une classe deja prete pour les listes chainees mais c'est le professeur qui nous a demander de faire cela.

Moi je veux un itérateur pour ma liste chainée faite maison et pas la classe LinkedList déjà définie dans le langage.

En tous cas je donne mon essai

Code:

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
@Override
	public Iterator<T> iterator() {
		liste=new  ListeAdtImpl<T>();
	    Iterator<T> it=liste.iterator();
		// TODO Auto-generated method stub
		return it;
	}
 
 
	@Override
	public boolean hasNext() {
		Noeud<T> courrant=tete;
		if(courrant.getSuivant()!=null){
			return true;
		}
		// TODO Auto-generated method stub
		// Noeud<T> courrant=tete
		return false;
	}
 
	@Override
	public T next() {
		// TODO Auto-generated method stub
		Noeud<T> courrant=tete;
		if(hasNext()){
			courrant=courrant.getSuivant();
		}
		return courrant.getElement();
	}

Salut,

le principe est d'implémenter Iterable<T> sur ta classe (apparement ListeAdtImpl<T>) donc de cette manière par exemple:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class ListeAdtImpl<T> implements Iterable<T> {
 
    public Iterator<T> iterator() {
         return new ListeAdtImplIterator();
    }
 
    private class ListeAdtImplIterator implements Iterator<T> {
 
          public boolean hasNext() {
                  // le code adéquate pour indiquer s'il reste des éléments
          }
 
          public T next() {
                  // le code adéquate pour retourner la prochaine valeur à lire (ou une exception NoSuchElementException s'il n'y en a pas
          }
 
          public void remove() {
                 // le code adéquate pour supprimer la dernière valeur obtenue par next(), ou une exception IllegalStateException siaucune valeur n'a été lue, ou si la dernière valeur lue a déjà été supprimée par l'appel de cette méthode
                // ou eventuellement UnsupporterdOperationException si tu ne veux pas qu'un puisse supprimer          
         }
 
    }
 
}

Comme tu n'as pas mis le code complet de ta classe, je suis obligé d'imaginer le nom des variables que tu as utilisées pour montrer l'exemple d'un iterateur

donc imaginons que ta liste chainée est fondée sur :

- une classe interne Element<T> ayant pour variable de type T valeur pour la valeur et suivant pour l'élément suivant (de type Element<T>)
- une variable premier de type Element<T> pour le premier element de la liste

un truc dans le genre par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private class Element<T> {
     private T valeur;
     private Element<T> suivant;
     public Element() {
     }
     public Element(T valeur) {
        setValeur(valeur);
     }
     public void setValeur(T valeur) {
        this.valeur=valeur;
     }
     public T getValeur() {
        return valeur;
     }
     public void setSuivant(Element<T> suivant) {
        this.suivant=suivant;
     }
     public Element<T> getSuivant() {
        return suivant;
     }
}

Code:

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
public class ListeAdtImpl<T> implements Iterable<T> {
 
    private Element<T> premier;
 
    public ListAdtImpl(){
    }
 
    public void add(T valeur) {
        if ( premier==null ) premier=new Element<T>(valeur);
        else {
            Element<T> dernier=premier;
            while(dernier.getSuivant()!=null) {
                dernier=dernier.getSuivant();
            }
            dernier.setSuivant(new Element<T>(valeur));
        }
    }
 
    public Iterator<T> iterator() {
         return new ListeAdtImplIterator();
    }
 
private class ListeAdtImplIterator implements Iterator<T> {
 
          private Element<T> courant;
 
          public ListeAdtImplIterator() {
              courant=premier;
          }
 
          public boolean hasNext() {
                return courant!=null;
          }
 
          public T next() {
                if ( courant==null ) throw new NoSuchElementException();
                T valeur = courant.getValeur();
                courant = courant.getSuivant();
                return valeur;
          }
 
          public void remove() {
                throw new UnsupportedOperationException();       
         }
 
    }
 
 
 
}

14/11/2013, 02h03
small44

Merci c'est ca se que je cherche mais il faut que je redefinis aussi la methode Iterator de l'interfce Iterable cet methode a l'air plus difficile que next et hasNext.
14/11/2013, 02h16
joel.drigo
Citation:

Envoyé par small44

Merci c'est ca se que je cherche mais il faut que je redefinis aussi la methode Iterator de l'interfce Iterable cet methode a l'air plus difficile que next et hasNext.

Mais 8O, je l'ai mise la méthode iterator() de l'interface Iterable (et elle est pas plus difficile que celles de Iterator) :
Code:

1 2 3 public Iterator<T> iterator() { return new ListeAdtImplIterator(); }
C'est juste une méthode qui retourne une instance de classe implémentant l'interface Iterator.
14/11/2013, 18h10
small44

J'ai qu'une seule classe qui implemente les deux interfaces Iterator et Iterable dans ce que est ce qu'il suffit de retourner une instance de ma classe dans la methode Iterator?

Citation:

Envoyé par small44

J'ai qu'une seule classe qui implemente les deux interfaces Iterator et Iterable dans ce que est ce qu'il suffit de retourner une instance de ma classe dans la methode Iterator?

oui dans ce cas oui, il suffit de faire :
Code:

1 2 3 public Iterator<T> iterator() { return this; }
Mais il ne faut pas faire ça, car ton iterateur ne pourra être utilisé qu'une seule fois : lorsqu'il sera arrivé au bout, il ne pourra plus être appelé.
En plus, si tu l'utilises dans plusieurs boucles simultanées, ça va être le bocson.

Imagines que tu fasses :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 int[] input = new int[]{100,200,300}; ListAdtImpl<Integer> liste = new ListAdtImpl<Integer>(); int p=0; for(int value1 : input) { System.out.println("Ajout " + value1); listAdtImpl.add(value1); System.out.println("Liste chainée après ajout " + value1); for(Integer value2 : liste) { System.out.print("->"; System.out.print(value2); } System.out.println(); } ...
Quel résultat ?

Ca done ce resultat la

Code:

1
2
3
4
5
6
7
8
9
 
Ajout 100
Liste chainée après ajout 100
 
Ajout 200
Liste chainée après ajout 200
 
Ajout 300
Liste chainée après ajout 300

14/11/2013, 20h24
joel.drigo
Citation:
Envoyé par small44

Ca done ce resultat la

Code:

1 2 3 4 5 6 7 8 9 Ajout 100 Liste chainée après ajout 100 Ajout 200 Liste chainée après ajout 200 Ajout 300 Liste chainée après ajout 300
Non, mais c'était une question réthorique :roll: et en plus le résultat est faux !!! y'a une erreur quelque part dans ton add

Mais même si le add était bon, le résultat serait foireux, j'espère que tu t'en rend compte 8O

on devrait avoir logiquement (si tout est bien codé, et que l'iterateur est bien une instance différente pour chaque appel à iterator())
```
Ajout 100
Liste chainée après ajout 100
->100

Ajout 200
Liste chainée après ajout 200
->100->200

Ajout 300
Liste chainée après ajout 300
->100->200->300
```
15/11/2013, 00h20
small44

J'ai pas bien compris pourquoi ca marchera pas avec return this;
C'est quoi la solutiob sinon?
15/11/2013, 01h35
joel.drigo
Citation:

Envoyé par small44

J'ai pas bien compris pourquoi ca marchera pas avec return this;

J'ai pas dit que return this; marche pas : j'ai dit qu'on n'implémente pas Iterator sur la liste sur laquelle on itére.

Un iterateur est un objet à état : le but est d'itérer (!), c'est-à-dire de récupérer chacune des valeurs successivement jusqu'à ce qu'il y en ait plus. Et quand on est arrivé à la fin, l'itérateur n'est plus utilisable : on consomme les valeurs à chaque itération.

Pour itérer on utilise une sorte curseur, qui "avance" dans une liste de valeurs. Le curseur est un état qui change.

Si l'itérateur d'une liste de valeurs est la liste elle-même, chaque fois qu'on itère, on avance le curseur, unique, forcément pour l'unique instance de l'itérateur :
1) s'il y'a plusieurs itérations, le curseur avance donc pour toutes, et il n'y en a qu'une seule qui obtiendra la valeur correspondant au curseur, qui sera "cramée" pour les autres. Le but est que chaque boucle puisse itérer sur l'ensemble des valeurs, à chaque fois que c'est nécessaire, et simultanément possiblement

2) et, en plus, quand tu arrives à la fin (quand hasNext() est false), ton itérateur est mort : si à un moment tu as besoin de nouveau d'itérer, tu ne peux plus !!!
Il peut y avoir des implémentations qui "ressuscitent" l'itérateur, en prolongeant la fin, mais c'est une implémentation incohérente. Si tu fais une boucle, tu dois pouvoir itérer en une fois et quand tu arrives à la fin, tu sors de la boucle : si tout d'un coup hasNext() se remet à retourner true, on est sorti de la boucle c'est trop tard.

C'est une implémentation inepte de l'itérateur...

Par exemple, lorsqu'on itère sur une liste, mettons liste = 1,2,3 :
Code:

1 2 3 pour chaque i dans liste faire pour chaque j dans liste on affiche i*j
Déroulement attendu :
```
itération i
next i
itération j
next j
affiche 1*1=1 (itération i=1, itération j=1)
next j
affiche 1*2=2 (itération i=1, itération j=2)
next j
affiche 1*3=3 (itération i=1, itération j=3)
fin itération j
next i
itération j
next j
affiche 2*1=2 (etc...)
next j
affiche 2*2=4
next j
affiche 2*3=6
fin itération j
next i
itération j
next j
affiche 3*1=3
next j
affiche 3*2=6
next j
affiche 3*3=9
fin itération j
fin itération i
```
Dans ton cas d'implémentation on obtiendrait :
```
itération i
next i
itération j (= itération i)
next j
affiche 1*2=2 (itération i=1, itération j=2)
next j
affiche 1*3=3 (itération i=1, itération j=3)
fin itération j (hasNext=false)
fin itération i (hasNext=false)
donc sortie de boucle 
```
C'est pourtant clair que ça ne fait pas ce que ça devrait faire !

Citation:

Envoyé par small44

C'est quoi la solutiob sinon?

Voir la classe interne dans mon post d'hier :roll:

Donc c'est seulement pas tres pratique mais juste puisque lorsque le curseur avance on perd les autres elements mais dans ce cas on peut creer une variable ou stocker les elements dans un tableaux

J'ai essayer votre code et j'arrive pas a le parcourir pour afficher mes elements lorsque je veux parcourir a la premiere iteration il ne rentre pas dans la boucle car hasNext() est toujours false
je vais vous metre mon code complets

-Classe noeud

Code:

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
 
package ca.uqam.inf2120.tp2.adt.impl;
 
public class Noeud<T> {
 private T element; //contenu du noeud
 private Noeud<T> suivant; //l`adresse du noeud suivant
 
public T getElement() {
	return element;
}
 
public void setElement(T element) {
	this.element = element;
}
 
public Noeud<T> getSuivant() {
	return suivant;
}
 
public void setSuivant(Noeud<T> suivant) {
	this.suivant = suivant;
}
 
public Noeud(){
 
}
 
public Noeud(T element){
	this.element=element;
}
 
public Noeud(Noeud<T> suivant){
	this.suivant=suivant;
}
 
public Noeud(T element,Noeud<T> suivant){
	this.suivant=suivant;
	this.element=element;
}
 
}

Interface ListeAdt implemente Iterable et Iterator

Code:

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
package ca.uqam.inf2120.tp2.adt;
 
import java.util.Iterator;
import java.util.Map;
 
 
 
/**
 * Université du  Québec à Montréal
 * Travail Pratique 2
 * Cours   : INF2120 - Groupe 20 
 * Session : Automne 2013  
 * 
 * ListeAdt : Cette interface contient un ensemble de services que vous devez
 * définir dans une classe nommée ListeAdtImpl. Les éléments doivent être ajoutés dans la 
 * liste en ordre croissant, autrement dit la liste doit toujours être ordonnée.
 *    
 * @author Ismael Doukoure
 * @version 29 octobre 2013
 */
public interface ListeAdt<T extends Comparable<T>> extends Iterable<T>, Iterator<T> { 
 
	/**
     * Si l'élément n'est pas null, il n'existe pas dans la liste courante, il est ajouté dans
     * la liste courante et la méthode retourne vrai, sinon elle retourne faux. 
     * 
     * Les éléments sont ajoutés dans la  liste en ordre croissant, autrement dit la liste doit 
     * toujours être ordonnée.
     *   
     * @param element L'élément à ajouter
     * @return true si l'élément n'est pas null, il n'existe pas dans la liste et qu'il est ajouté
     *         sinon false.
     */
    public boolean ajouter(T element);
 
    /**
     * Ajouter tous les éléments de la liste passée en paramètre dans la liste courante et 
     * retourne un tableau des éléments qui n'ont pas été ajouté, car ils existent déjà.
     * 
     * Les éléments sont ajoutés dans la liste en ordre croissant, autrement dit la liste doit 
     * toujours être ordonnée.
     *   
     * @param liste La liste dont les éléments doivent être ajoutés
     * @return Le tableau des éléments qui n'ont pas été ajoutés, null si tous les éléments
     *         ont été ajoutés ou la liste passée en paramètre est nulle ou vide 
     */
    public T[] ajouter(ListeAdt<T> liste);
 
    /**
     * L'élément passé en paramètre doit être supprimé s'il existe dans la liste courante.
     * 
     * @param element L'élément à supprimer
     * @return true si l'élément est supprimé, sinon faux 
     */
 
     public boolean supprimer(T element);
 
    /**
     * Tous les éléments de la liste passée en paramètre doivent être supprimés dans la liste
     * courante s'ils existent.     
     *  
     * @param liste La liste dont les éléments doivent être supprimés
     * @return Le tableau des éléments qui n'ont pas été supprimés, null si tous les éléments
     *         ont été supprimés ou la liste passée en paramètre est nulle ou vide
     */
     public T[] supprimer(ListeAdt<T> liste);
 
     /**
      * Si la liste courante contient tous les éléments de la liste passée en paramètre, 
      * la méthode retourne vrai, sinon elle retourne faux.       
      *           
      * @param liste  La liste dont l'existence de tous les éléments doit être vérifiée
      * @return true si la liste courante contient tous les éléments de la liste passée
      *         en paramétre, sinon false
      */
     public boolean contientTout(ListeAdt<T> liste);
 
    /**
     * Remplacer un élément par un autre dans la liste courante. L'élément à remplacer doit 
     * exister et le nouveau élément ne doit pas être null. Aucun remplacement si le nouveau
     * élément existe déjà dans la liste. L'ordre des éléments doit être respecté après tout
     * remplacement
     * 
     * @param elementARemplacer L'élement de la liste courante à remplacer
     * @param nouveauElement Le nouveau élément à ajouter
     * @return true si le remplacement a été fait, sinon faux.
     */
     public boolean remplacer(T elementARemplacer, T nouveauElement);
 
     /**
      * Retourner les éléments de la liste courante et leurs positions dans un HashMap
      * (HashMap Clé = position de type Integer, HashMap valeur = élément de type T).
      * Les éléments rétournés dovient être entre les positions de début et de fin 
      * inclusivement. La valeur nulle doit être retournée si la position de début est
      * égale à la position de fin.  
      * 
      * @param positionDebut La position de début
      * @param positionDebut La position de fin
      * @return Le HashMap des éléments de la liste courante dans l'intervalle spécifié et leurs positions.
      * @throws PositionException Cette exception sera lancée si la poisiton de début < 0,
      *         si la position de fin > nombre d'éléments dans la liste ou si la position de début > 
      *         la position de fin.
      */
      public  Map<Integer, T> elements(int positionDebut, int positionFin) throws PositionException;
 
     /**
      * Si la liste courante contient l'élément passé en paramètre, la methode retourne 
      * vrai, sinon elle retourne faux.
      * 
      * @param element L'élement dont l'existence doit être vérifiée
      * @return true si l'élément existe, sinon faux
      */
      public boolean estElement(T element);
 
      /**
       * Le nombre total des éléments dans la liste courante doit être retourné.
       * 
       * @return Le nombre total des éléments de la liste courante
       */
       public int nbElements();
 
 
      /**
       * Vider la liste courante,.
       */
       public void vider();
 
       /**
        * Vérifier si la liste courante est vide.
        * 
        * @return true si la liste courante est vide, sinon false.
        */
        public boolean estVide();
 
        /* ***************************************************************************************
         * INFORMATIONS IMPORTANTES : Étant donné que ListeAdt hérite des interfaces
         * Iterable<T>, Iterator<T>, vous devez définir toutes les méthodes qui sont
         * déclarées dans ces interfaces (SAUF la méthode remove de l'interface Iterator<T>)
         * dans votre classe ListeAdtImpl qui implémente l'interface ListeAdt. Voir
         * ci-dessous pour les détails :
         *
         *
         * Iterable<T>
         * Cette interface contient une seule méthode "public Iterator<T> iterator()"
         * qui retourne un iterator sur la liste courante. Vous devez implanter cette
         * methode dans votre classe
         *
         *
         * Iterator<T>
         * Cette interface contient trois méthodes:
         *
         *   - public boolean hasNext() : Vérifie s'il y a un élément à partir de la
         *     position courante dans la liste
         *
         *   - public T next() : Retourner l'élément à la position courante et
         *     repositionne le curseur (l'itérateur) sur l'élément suivant.
         *
         *   - public void remove () : À NE PAS DÉFINIR. Donc cette méthode sera vide avec
         *     juste les accolades ouvrante et fermante.
         *
         ********************************************************************************************/
 
}

classe implementant l'interface listeAdt

Code:

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
 
package ca.uqam.inf2120.tp2.adt.impl;
 
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
 
import ca.uqam.inf2120.tp2.adt.ListeAdt;
import ca.uqam.inf2120.tp2.adt.PositionException;
 
public class ListeAdtImpl<T extends Comparable<T>> implements ListeAdt<T> {
	ListeAdtImpl<T> liste;
	Noeud<T> tete;
	Noeud<T> courrant = tete;
	private int nbElements;
 
	public ListeAdtImpl() {
		tete = null;
		nbElements = 0;
	}
 
	@Override
	public Iterator<T> iterator() {
		return this;
 
	}
 
	@Override
	public boolean hasNext() {
		return courrant != null;
	}
 
	@Override
	public T next() {
		// TODO Auto-generated method stub
		/*
		 * T valeur=null; if ( hasNext() ){ valeur = courrant.getElement();
		 * courrant = courrant.getSuivant(); } return valeur;
		 */
 
		if (courrant == null)
			throw new NoSuchElementException();
		T valeur = courrant.getElement();
		courrant = courrant.getSuivant();
		return valeur;
	}
 
	@Override
	public void remove() {
		// TODO Auto-generated method stub
 
	}
 
	/**
         * Si l'élément n'est pas null, il n'existe pas dans la liste courante, il
         * est ajouté dans la liste courante et la méthode retourne vrai, sinon elle
         * retourne faux.
         * 
         * Les éléments sont ajoutés dans la liste en ordre croissant, autrement dit
         * la liste doit toujours être ordonnée.
         * 
         * @param element
         *            L'élément à ajouter
         * @return true si l'élément n'est pas null, il n'existe pas dans la liste
         *         et qu'il est ajouté sinon false.
         */
	@Override
	public boolean ajouter(T element) {
		// TODO Auto-generated method stub
 
		Noeud<T> courant = tete;
		Noeud<T> suivant = tete;
		boolean ajouter = false;
		if (element != null && !estElement(element)) {
			ajouter = true;
			if (tete == null) {
				tete = new Noeud<T>(element);
			} else {
				if (tete.getElement().compareTo(element) > 0) {
					tete = new Noeud<T>(element, tete);
				} else {
					suivant = suivant.getSuivant();
					while (suivant != null
							&& courant.getElement().compareTo(element) < 0
							&& suivant.getElement().compareTo(element) < 0) {
						courant = courant.getSuivant();
						suivant = suivant.getSuivant();
					}
					courant.setSuivant(new Noeud<T>(element, suivant));
 
				}
				nbElements++;
			}
		}
 
		return ajouter;
	}
 
	/**
         * Ajouter tous les éléments de la liste passée en paramètre dans la liste
         * courante et retourne un tableau des éléments qui n'ont pas été ajouté,
         * car ils existent déjà.
         * 
         * Les éléments sont ajoutés dans la liste en ordre croissant, autrement dit
         * la liste doit toujours être ordonnée.
         * 
         * @param liste
         *            La liste dont les éléments doivent être ajoutés
         * @return Le tableau des éléments qui n'ont pas été ajoutés, null si tous
         *         les éléments ont été ajoutés ou la liste passée en paramètre est
         *         nulle ou vide
         */
	@Override
	public T[] ajouter(ListeAdt<T> liste) {
		// TODO Auto-generated method stub
		List<T> tableauArrayList = new ArrayList<T>();
 
		T notNullItem = null;
		Iterator<T> li = liste.iterator();
 
		while (li.hasNext()) {
			T temp = li.next();
 
			if (liste.estElement(temp) == false) {
				ajouter(temp);
			}
 
			else {
				tableauArrayList.add(temp);
			}
 
			if (notNullItem == null)
				notNullItem = temp;
		}
 
		/*
		 * toArray convertie la liste en tableau notNullItem.getClasse() permet
		 * de determiner le type de tableau lors de l'excecution
		 */
		return tableauArrayList.toArray((T[]) Array.newInstance(
				notNullItem.getClass(), liste.nbElements()));
	}
 
	/**
         * L'élément passé en paramètre doit être supprimé s'il existe dans la liste
         * courante.
         * 
         * @param element
         *            L'élément à supprimer
         * @return true si l'élément est supprimé, sinon faux
         */
	@Override
	public boolean supprimer(T element) {
		boolean estSupprimer = false;
		Noeud<T> courrant = tete;
		Noeud<T> precedent = tete;
		if (courrant.getSuivant() == null) {
			new NullPointerException();
		} else if (nbElements == 1) {
			vider();
		} else {
			if (!estVide() && estElement(element)) {
				while (courrant != null
						&& element.compareTo(courrant.getElement()) != 0) {
					precedent = courrant;
					courrant = courrant.getSuivant();
				}
				precedent.setSuivant(courrant.getSuivant());
				nbElements--;
				estSupprimer = true;
			}
		}
		return estSupprimer;
	}
 
	/**
         * Tous les éléments de la liste passée en paramètre doivent être supprimés
         * dans la liste courante s'ils existent.
         * 
         * @param liste
         *            La liste dont les éléments doivent être supprimés
         * @return Le tableau des éléments qui n'ont pas été supprimés, null si tous
         *         les éléments ont été supprimés ou la liste passée en paramètre
         *         est nulle ou vide
         */
	@Override
	public T[] supprimer(ListeAdt<T> liste) {
		// TODO Auto-generated method stub
		List<T> tableauArrayList = new ArrayList<T>();
		T notNullItem = null;
		Iterator<T> li = liste.iterator();
 
		while (li.hasNext()) {
			T temp = li.next();
 
			if (estElement(temp)) {
				supprimer(temp);
			}
 
			else {
				tableauArrayList.add(temp);
			}
 
			if (notNullItem == null)
				notNullItem = temp;
		}
 
		return tableauArrayList.toArray((T[]) Array.newInstance(
				notNullItem.getClass(), liste.nbElements()));
	}
 
	/**
         * Si la liste courante contient tous les éléments de la liste passée en
         * paramètre, la méthode retourne vrai, sinon elle retourne faux.
         * 
         * @param liste
         *            La liste dont l'existence de tous les éléments doit être
         *            vérifiée
         * @return true si la liste courante contient tous les éléments de la liste
         *         passée en paramétre, sinon false
         */
	@Override
	public boolean contientTout(ListeAdt<T> liste) {
		// TODO Auto-generated method stub
		boolean contientTous = false;
 
		/*
		 * for(Noeud<T> courrant=tete;courrant!=null;courrant.getSuivant()){
		 * 
		 * } if(){
		 * 
		 * }
		 */
		return contientTous;
	}
 
	/**
         * Remplacer un élément par un autre dans la liste courante. L'élément à
         * remplacer doit exister et le nouveau élément ne doit pas être null. Aucun
         * remplacement si le nouveau élément existe déjà dans la liste. L'ordre des
         * éléments doit être respecté après tout remplacement
         * 
         * @param elementARemplacer
         *            L'élement de la liste courante à remplacer
         * @param nouveauElement
         *            Le nouveau élément à ajouter
         * @return true si le remplacement a été fait, sinon faux.
         */
	@Override
	public boolean remplacer(T elementARemplacer, T nouveauElement) {
		// TODO Auto-generated method stub
		Noeud<T> courrant = tete;
		boolean estRemplacer = false;
		if (!estElement(nouveauElement)) {
			while (courrant != null
					&& !courrant.getElement().equals(elementARemplacer)) {
				courrant = courrant.getSuivant();
			}
			courrant.setElement(nouveauElement);
			estRemplacer = true;
 
		}
 
		return estRemplacer;
	}
 
	/**
         * Retourner les éléments de la liste courante et leurs positions dans un
         * HashMap (HashMap Clé = position de type Integer, HashMap valeur = élément
         * de type T). Les éléments rétournés dovient être entre les positions de
         * début et de fin inclusivement. La valeur nulle doit être retournée si la
         * position de début est égale à la position de fin.
         * 
         * @param positionDebut
         *            La position de début
         * @param positionDebut
         *            La position de fin
         * @return Le HashMap des éléments de la liste courante dans l'intervalle
         *         spécifié et leurs positions.
         * @throws PositionException
         *             Cette exception sera lancée si la poisiton de début < 0, si
         *             la position de fin > nombre d'éléments dans la liste ou si la
         *             position de début > la position de fin.
         */
	@Override
	public Map<Integer, T> elements(int positionDebut, int positionFin)
			throws PositionException {
		// TODO Auto-generated method stub
		int position = 0;
		Map<Integer, T> hm = new HashMap<Integer, T>();
		Noeud<T> courrant = tete;
 
		if (positionDebut < 0 && positionFin > 0 || positionDebut > positionFin) {
			new PositionException();
		}
 
		while (courrant != null) {
			courrant = courrant.getSuivant();
			position++;
			if (position >= positionDebut && position <= positionFin) {
				for (int i = positionDebut; i < positionFin; i++) {
					hm.put(i, courrant.getElement());
				}
 
			}
		}
 
		return hm;
	}
 
	/**
         * Si la liste courante contient l'élément passé en paramètre, la methode
         * retourne vrai, sinon elle retourne faux.
         * 
         * @param element
         *            L'élement dont l'existence doit être vérifiée
         * @return true si l'élément existe, sinon faux
         */
	@Override
	public boolean estElement(T element) {
 
		boolean trouve = false;
		Noeud<T> courrant = tete;
		while (!trouve && courrant != null) {
			if (courrant.getElement() == element) {
				trouve = true;
			} else {
				courrant = courrant.getSuivant();
			}
		}
		return trouve;
	}
 
	/**
         * Le nombre total des éléments dans la liste courante doit être retourné.
         * 
         * @return Le nombre total des éléments de la liste courante
         */
	@Override
	public int nbElements() {
		// TODO Auto-generated method stub
		return nbElements;
	}
 
	/**
         * Vider la liste courante,.
         */
	@Override
	public void vider() {
		// TODO Auto-generated method stub
		tete = null;
		nbElements = 0;
	}
 
	/**
         * Vérifier si la liste courante est vide.
         * 
         * @return true si la liste courante est vide, sinon false.
         */
	@Override
	public boolean estVide() {
		// TODO Auto-generated method stub
		return nbElements == 0;
	}
 
	/*
	 * asupprimer juste pour tester le code
	 */
	public String toString() {
		Noeud<T> courrant = tete;
		String chaine = "|";
		while (courrant != null) {
			chaine += courrant.getElement() + "|";
			courrant = courrant.getSuivant();
		}
		return chaine;
	}
 
	public int posElement(T element) {
		Noeud<T> courrant = tete;
		int position = 0;
		if (!this.estElement(element)) {
			return -1;
		} else {
			while (courrant != null && !courrant.getElement().equals(element)) {
				courrant = courrant.getSuivant();
				position++;
			}
		}
		return position;
	}
 
}

Main

Code:

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
 
package ca.uqam.inf2120.tp2.adt.impl;
 
import java.util.*;
 
import ca.uqam.inf2120.tp2.adt.PositionException;
 
public class Main {
 
	public static void main(String[] args) throws PositionException {
 
  ListeAdtImpl<String> liste2 = new ListeAdtImpl<String>();
  int p=0;
  String[] input = new String[]{"salut","bonjour","cava"};
  for(String value1 : input) {
 
	   System.out.println("Ajout " + value1);
	    liste2.ajouter(value1);
 
	   System.out.println("Liste chainée après ajout " + value1);
	   for(String value2 : liste2) {
	       System.out.print("->");
	       System.out.print(value2);
	   }
	   System.out.println();
 
	}
 
 
 
 
	}
 
}
 
 
	}
 
}

Classe d'exception

Code:

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
 
package ca.uqam.inf2120.tp2.adt;
 
/**
 * Université du  Québec à Montréal
 * Travail Pratique 2
 * Cours   : INF2120 - Groupe 20 
 * Session : Automne 2013 
 * 
 * Classe pour gérer les exceptions liées à une position dans un intervalle
 *  - Si la position n'est pas dans l'intervalle spécifié
 *  - Si la position de début est plus grande que celle de fin
 * 
 * @author Ismael Doukoure
 * @version 29 octobre 2013
 */
@SuppressWarnings("serial")
public class PositionException extends Exception{
 
	/**
         * Constructeur sans argument
         */	
	public PositionException() {
        super();
    }
 
	/**
         * Permet d'initialiser le message
         * @param message Message à afficher
         */
	public PositionException(String message) {
        super(message);
    }
 
}

Citation:

Envoyé par small44

Donc c'est seulement pas tres pratique mais juste puisque lorsque le curseur avance on perd les autres elements mais dans ce cas on peut creer une variable ou stocker les elements dans un tableaux

**soupirs**
Je suis currieux de voir cette solution :roll: Tu l'a créérais ou et quand ta variable ???

Citation:

Envoyé par small44

J'ai essayer votre code et j'arrive pas a le parcourir pour afficher mes elements lorsque je veux parcourir a la premiere iteration il ne rentre pas dans la boucle car hasNext() est toujours false

Tu as du te planter quelque part parce que ça marche très bien quand je le fais :

Ajout salut
Liste chainée après ajout salut
->salut
Ajout bonjour
Liste chainée après ajout bonjour
->bonjour->salut
Ajout cava
Liste chainée après ajout cava
->bonjour->cava->salut

Code:

1
2
3
4
5
public interface ListeAdt<T extends Comparable<T>> extends Iterable<T> { 
 
...
 
}

Code:

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
public class ListeAdtImpl<T extends Comparable<T>> implements ListeAdt<T> {
 
...
 
@Override
	public Iterator<T> iterator() {
		return new ListeAdtImplIterator();
 
	}
 
	private class ListeAdtImplIterator implements Iterator<T> {
 
        private Noeud<T> courant;
 
        public ListeAdtImplIterator() {
            courant=tete;
        }
 
        public boolean hasNext() {
              return courant!=null;
        }
 
        public T next() {
              if ( courant==null ) throw new NoSuchElementException();
              T valeur = courant.getElement();
              courant = courant.getSuivant();
              return valeur;
        }
 
        public void remove() {
              throw new UnsupportedOperationException();       
       }
 
  }
 
...
 
}

15/11/2013, 17h54
small44
Quand je teste ma liste en regardant les elements de la liste en redefinisant le tous string ca m'affiche bien les elements mais avec l'iterateur des la premiere boucle hasNext() est false donc ca ne doit pas etre la methode ajouter le probleme.

Peut etre j'ai mal utiliser l'iterateur j'ai fait comme ca
Code:

1 2 3 4 5 6 Iterator<T> it = liste.iterator(); while(liste.hasNext()){ String element=liste.next(); System.out.println(element); }

Citation:
Envoyé par small44
Quand je teste ma liste en regardant les elements de la liste en redefinisant le tous string ca m'affiche bien les elements mais avec l'iterateur des la premiere boucle hasNext() est false donc ca ne doit pas etre la methode ajouter le probleme.

Peut etre j'ai mal utiliser l'iterateur j'ai fait comme ca
Code:

1 2 3 4 5 6 Iterator<T> it = liste.iterator(); while(liste.hasNext()){ String element=liste.next(); System.out.println(element); }
1) c'est quoi ce bout de code étrange et inepte ? Quel rapport avec une implémentation de ListeAdtImpl.toString() (et pas le "tous string" :weird:) ?

Tu créé un itérateur it par appel de liste.iterator(), puis tu itères en appelant hasNext() de liste 8O
On itère sur une instance d'iterateur en appelant les méthodes de cette instance d'itérateur :roll:

2) si j'implémente toString() à partir de iterator(), lors de la première itération, hasNext() est false uniquement si la liste est vide...

Mais j'implémente toString() comme ça (par exemple) :
Code:

1 2 3 4 5 6 7 8 9 10 11 public String toString() { StringBuilder sb=new StringBuilder(); sb.append('('); Iterator<T> it = iterator(); while(it.hasNext()){ sb.append(it.next()); if ( it.hasNext() ) sb.append(','); } sb.append(')'); return sb.toString(); }

Je pensais qu'on utilise un iterateur redefinis comme la classe predefinis dans java.

Pour la redefinition de toString j'ai pas utiliser l'iterateur dedans mais partouru avec un Noeud<T> courrant
Code:

1 2 3 4 5 6 7 8 9 10 public String toString() { Noeud<T> courrant = tete; String chaine = "|"; while (courrant != null) { chaine += courrant.getElement() + "|"; courrant = courrant.getSuivant(); } return chaine; }

Citation:
Envoyé par small44
Je pensais qu'on utilise un iterateur redefinis comme la classe predefinis dans java.

Pour la redefinition de toString j'ai pas utiliser l'iterateur dedans mais partouru avec un Noeud<T> courrant
Code:

1 2 3 4 5 6 7 8 9 10 public String toString() { Noeud<T> courrant = tete; String chaine = "|"; while (courrant != null) { chaine += courrant.getElement() + "|"; courrant = courrant.getSuivant(); } return chaine; }
Si tu veux... mais utilises au moins un StringBuilder...

16/11/2013, 02h14
small44

Ca marche enfin ,merci pour tous le temps que tu a consacre a moi