implémenter un Iterator spécial
bonjour,
je dois rendre un TP avant ce soir minuit. Il y a 14 questions et je n'en suis qu'à la question 2.
Je n'ai pas eu de cours sur ce sujet et galère
Définissez une classe HashMultiSetIterator qui implante Iterator<T> en respectant les spécifications suivantes (nous conseillons de définir HashMultiSetIterator comme une classe interne à HashMultiSet<T>
- Si un élément e apparaît n fois dans un multi-ensemble, alors l’itérateur retournera l’élément e pour les n prochains appels à next(), avant de passer à l’élément suivant.
- Afin d’élaborer notre itérateur de multi-ensembles, nous nous appuierons par délégation sur un itérateur parcourant la collection Map<T,Integer> au cœur de l’implantation de HashMultiSet<T>.
Un appel à next() de l’itérateur de multi-ensemble ne se
traduira pas systématiquement par un appel à next() de l’itérateur sous-jacent : il faut tenir compte des nombres d’occurrences.
voici ce que j'ai fait pour la question 1 :
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
| package pobj.multiset;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
public interface MultiSet<T> {
public boolean add(T e, int count);
public boolean add(T e);
public boolean remove(Object e);
public boolean remove(Object e, int count);
public int count(T o);
public void clear();
public int size();
}
public class HashMultiSet<T> implements MultiSet<T> {
/**
* Contient les donnees du multi ensemble.
*/
private Map<T, Integer> memory;
/**
* Constructeur par defaut.
*/
public HashMultiSet() {
memory = new HashMap<T, Integer>();
}
/**
* Constructeur par copie.
* @param data donnees a copier
*/
public HashMultiSet(Collection<T> data) {
memory = new HashMap<T, Integer>();
//nous parcourons la collection, et mettons a jour notre multi-ensemble
for(T element : data){
Integer newOccur = 1;
Integer occur = memory.get(element);
if(occur != null){
//si un element est deja connu, alors nous mettons a jour son nombre d'occurence
//pour cela on recupere d'abord son occurence actuelle (qui n'est pas nulle)
newOccur = newOccur + occur;
}
//sinon cela veut dire que c'est un nouvel element
//donc on met une occurence (par defaut newOccur vaut 1);
memory.put(element, newOccur);
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean add(T e, int count) {
//on recupere d'abord le nombre d'occurence deja stockee
Integer occur = memory.get(e);
Integer newOccur = count;
if(occur!= null) {
newOccur = newOccur + occur;
}
memory.put(e, newOccur);
return true;
}
/**
* {@inheritDoc}
*/
@Override
public boolean add(T e) {
//on recupere d'abord le nombre d'occurence deja stockee
Integer occur = memory.get(e);
Integer newOccur = 1;
if(occur!= null) {
newOccur += occur;
}
memory.put(e, newOccur);
return true;
}
/**
* {@inheritDoc}
*/
@Override
public boolean remove(Object e) {
//on recupere d'abord le nombre d'occurence deja stockee
Integer occur = memory.get(e);
boolean result = false;
//seulement si le nombre d'occurence existe et qu'il est positif, on procede a la mise a jour
if(occur != null) {
//si il n'y avait qu'une occurence initialement, alors on suppriment l'element
if(occur == 1){
memory.remove(e);
//on met a jour le "flag" result pour dire que l'operation s'est bien passee.
result = true;
}
else if(occur > 1){
//on decremente le nombre d'occurence
occur--;
//on n'oublie pas de mettre a jour l'occurence
//voir "Alerte Unckeched cast" qui explique le warning a la ligne ci-dessous
memory.put((T) e, occur);
//on met a jour le "flag" result pour dire que l'operation s'est bien passee.
result = true;
}
}
return result;
}
/**
* {@inheritDoc}
*/
@Override
public boolean remove(Object e, int count) {
//on recupere d'abord le nombre d'occurence deja stockee
Integer occur = memory.get(e);
boolean result = false;
//seulement si le nombre d'occurence actuel existe
if(occur != null){
//si la suppression d'occurence est positive
occur =- count;
if(occur > 0) {
//on met à jour
//voir "Alerte Unckeched cast" qui explique le warning a la ligne ci-dessous
memory.put((T)e, occur);
}
//sinon on supprime l'element
else {
memory.remove(e);
}
result = true;
}
return result;
}
/**
* {@inheritDoc}
*/
@Override
public int count(T o) {
Integer occurence = memory.get(o);
//on renvoie le nombre d’occurrences de l’objet e dans la collection (0 si l’objet n’est pas
//dans le multi-ensemble)
return (occurence == null) ? 0 : occurence;
}
/**
* {@inheritDoc}
*/
@Override
public void clear() {
//on vide juste en se basant sur la methode existante de HashMap.
memory.clear();
}
/**
* indique la taille du multi-ensemble, c’est-à-dire la somme des nombres d’occurrences
* des éléments
*/
@Override
public int size() {merc
return memory.size;
}
}
// |
merci pour vos réponses sur comment je dois faire pour cette question
