Iterator - empêcher remove

Version imprimable

Bonjour,

Je me remets au java. Je suis un peu rouillé, j'ai pas pratiqué depuis un moment. Je suis un peu gêné sur un problème d'iterateur.

En effet, le but serait d'empêcher le remove avec l'iterateur via une exception. Je ne vois pas trop comment faire.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class MaClasse { private List<SubscriberI> souscripteurs; public MaClasse (){ this.souscripteurs = new LinkedList<SubscriberI>(); } //..... // Parcours, sans retrait possible, retourne un iterateur public Iterator<Topic> iterator(){ Iterator it = souscripteurs.iterator(); // ici return it; }
Je pensais faire quelque chose dans l'esprit de "Si appel de remove alors Exception". Mais comment faire ?

Merci d'avance

Salut,

Il te faut pour cela encapsuler l'itérateur sur lequel tu veux itérer dans un itérateur où tu empêche le remove().

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
public class DenyRemoveIterator<T> implements Iterator<T> {
 
	private final Iterator<T> iterator;
 
	public DenyRemoveIterator(Iterator<T> iterator) {
		this.iterator=iterator;
	}
 
	@Override
	public final boolean hasNext() {
		return iterator.hasNext();
	}
 
	@Override
	public final T next() {
		return iterator.next();
	}
 
	/* en Java8 cette méthode est déjà implémenté comme ça en défault method, 
	 * mais en Java7, il faut la mettre explicitement (donc décommenter)
         * Tu peux la décommenter en Java8 bien sûr, si tu veux
	@Override
	public final void remove() {
		throw new UnsupportedOperationException();
	}
	 */
 
}

Et tu modifies ta classe :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class MaClasse {
 
  private List<SubscriberI> souscripteurs;
 
 
 
  public MaClasse (){
   this.souscripteurs     = new LinkedList<SubscriberI>();
 }
//.....
 
// Parcours, sans retrait possible, retourne un iterateur 
 public Iterator<Topic> iterator(){
    Iterator it = souscripteurs.iterator();
   return new DenyRemoveIterator<>(it);
}

01/03/2015, 01h34
thelvin
Ou alors un truc tout con :
Code:

1 2 3 public Iterator<Topic> iterator(){ return Collections.unmodifiableCollection(souscripteurs).iterator(); }
Ça fera que UnsupportedOperationException, on peut pas choisir, mais ça marche et c'est facile.

Encore une autre possibilité, depuis Java 1.8, renvoyer un Stream au lieu d'un Iterator. Les Stream sont en lecture seule, ils n'exposent rien pour faire des modifications :
Code:

1 2 3 public Stream<Topic> stream(){ return souscripteurs.stream(); }

J'étais pas loin, c'est rassurant, je pensais faire un truc de la sorte mais je voyais pas comment y parvenir.

Je suis confronté à un autre petit souci, j'ai une erreur de cast.

Le but de tout ça, c'est de permettre aux abonnés ayant souscrit à un type d’événements, d’être prévenus lorsque ceux-ci se produisent. Un médiateur se charge de l’inscription des abonnés aux différents thèmes de souscription et assure la notification des évènements.

J'ai donc un ensemble de classes (je ne mets pas les interfaces) : Subscriber, Topic (abstraite), Mediator.

La classe Subscriber :

Code:

1
2
3
4
5
6
7
8
9
10
11
public abstract class Subscriber implements SubscriberI {
  private   Topic topic;     // thème souscrit
  private   int priority;    // priorité du souscripteur
  private   boolean aborted; // arrêt de la notification
 
  public Subscriber(Topic topic){
    this.topic = topic;
  }
 
 //...
}

La classe Mediator :

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
public class Mediator implements MediatorI{
 
  private List<SubscriberI> subscribers;
  private List<SubscriberI> deadSubscribers;
 
 
  public Mediator(){
   this.subscribers     = new LinkedList<SubscriberI>();
   this.deadSubscribers = new LinkedList<SubscriberI>();
  }
 
 
  public Mediator add(SubscriberI subscriber) throws Exception{
   //...fonctionne
  }
 
 
  public Mediator remove(SubscriberI subscriber) throws Exception{
   //..ok aussi
  }
 
 
  /** Obtention des souscripteurs à un thème.
   *  @param topic le thème souscrit
   *  @return la liste souscripteurs à ce thème, null si ce thème n’existe pas
   */
  public List<SubscriberI> getSubscribers(Topic topic){
     //...ok
  }
 
  //...
 
  }
 
   /** Obtention de tous les souscripteurs à un thème.
   *  @param topic le thème de publication
   *  @return la liste souscripteurs à ce thème, null si ce thème n’existe pas
   */
  public Iterator<Topic> iterator(){
   Iterator it = subscribers.iterator ();
 
    return new RemoveIterator<Topic>(it);
  }
 
 
 
  public static class RemoveIterator <T> implements Iterator<T> {
 
    public final Iterator<T> iterator;
 
    public RemoveIterator(Iterator<T> iterator) {
		this.iterator=iterator;
    }
 
    @Override
	public final boolean hasNext() {
		return iterator.hasNext();
	}
 
	@Override
	public final T next() {
		return iterator.next();
	}
 
 
	public final void remove() {
		throw new UnsupportedOperationException();
 
  }
}
 
 
}

Le jeu de tests est le suivant :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
protected void setUp(){
 	  this.mediator = new Mediator();
	  this.planif = new Planif(); //Planif herite de Topic
		this.s1 = new Sub("s1", planif);
             //...d'autres
		this.meteo = new Meteo(); //herite de Topic
	  this.s6 = new Sub("s6", meteo);
		this.s7 = new Sub("s7", meteo);
  }
 
public void testIterator() throws Exception{
	  mediator.add(s1).add(s6); // deux thèmes, deux abonnés 
  	Iterator<Topic> it = mediator.iterator();
    Topic t1 = it.next(); // ici que ça coince 
    assertTrue(" topic ?", t1.equals(planif) || t1.equals(meteo)); 
    Topic t2 = it.next();
    assertTrue(" topic ?", t2.equals(planif) || t2.equals(meteo));
    try{
      it = mediator.iterator();
      it.next();
      it.remove();

J'ai l'erreur suivante : TestPublishSubscribe$Sub cannot be cast to Topic

01/03/2015, 02h20
joel.drigo
Code:

1 2 3 4 5 6 7 private List<SubscriberI> subscribers; ... public Iterator<Topic> iterator(){ Iterator it = subscribers.iterator (); return new RemoveIterator<Topic>(it); }
it est un itérateur sur une liste typée SubstriberI, mais tu ne mets pas de type paramétré au type Iterator, ce qui te permet de la passer au constructeur.Tu peux le faire : mais tu as un warning qui te dit qu'il risque d'y avoir un problème de compatibilité de type, et c'est bien le cas au moment de l'appel de next(), car il y a une instance de TestPublishSubscribe.Sub (à priori le type de s1) qu'on essaye de mettre dans une variable de type Topic : donc un cast d'une classe vers une autre non compatible, d'où exception de casting.

Si tu utilises des types paramétrés, il faut les utiliser dans toute la chaîne, ce qui permet d'éviter d'avoir ce genre de problème (au moins d'être averti par le compilateur).
Code:

1 2 3 4 5 6 public Iterator<Topic> iterator(){ Iterator<Topic> it = subscribers.iterator (); return new RemoveIterator<Topic>(it); }
Tu aurais eu une erreur de compilation à la première ligne de la méthode.

Sinon il faut faire attention à ce qu'on fait et ne pas caster un Truc en un Machin pas compatible.

L'idée serait donc de générer une liste des topics suivis par les souscripteurs, de coller un iterateur sur cette liste en empêchant le remove, donc ?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //ajout nouvelle méthode public List<Topic> LesTopics(){ Iterator<SubscriberI> it = subscribers.iterator(); List<Topic> topics = new LinkedList<Topic>(); while (it.hasNext()){ SubscriberI souscripteur = it.next(); topics.add(souscripteur.getTopic()); } return topics; }
Mais comment récupérer cette liste dans la classe interne ? Quand je fais
Code:

1 2 3 4 5 6 //dans ma classe interne RemoveIterator public RemoveIterator() { this.iter=LesTopics().iterator(); }
je me retrouve avec une erreur à la compilation ? Je tâtonne un peu, désolé.

Comme ça, par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Subscriber {
 
	private final List<Topic> topics=new ArrayList<>();
 
	public void addTopic(Topic topic) {
		topics.add(topic);
	}
 
	public List<Topic> getTopics() {
		return Collections.unmodifiableList(topics);
	}
 
	public Iterator<Topic> iterator() {
		return topics.stream().iterator();
	}
 
}

01/03/2015, 17h34
roswellenshort

Merci à vous deux. Je n'ai plus d'erreur et j'obtiens des résultats cohérents. J'ai encore quelques questions, mais j'ai pas envie d'embêter.
02/03/2015, 09h54
kolodz

Pose tes questions ! Si ça nous embête on répondra pas. Mais, c'est peu probable !

Cordialement,
Patrick Kolodziejczyk.
07/03/2015, 12h19
roswellenshort

Merci pour les réponses. D'autres questions viendront si besoin au fur et à mesure :)