Discussion :

[teletexte]

Bonjour,

Voici mon problème. J'ai besoin de manipuler une collection avec pour propriété d'avoir des éléments sans doublons. Egalement ces éléments doivent être au besoin triés (suivant un comparable par exemple). Une implémentation correcte serait d'utiliser un TreeSet. Un problème subsiste néanmoins. Les propriétés des éléments peuvent être modifiés au cours de l'exécution du programme. Les éléments ne sont plus alors triés. Plusieurs solutions m'apparaissent mais me laisse songeur :

1. Plutôt qu'un TreeSet, on choisit une ArrayList. Les opérations d'ajout sont redéfinies pour assurer l'unicité des éléments. On complète en rajoutant un appel à sort de Collections.
2. On garde TreeSet, mais à chaque modification d'un élément, on veille à le retirer de la liste puis à le rejouter.
3. On garde TreeSet, mais on ajoute une opération qui consiste à "retrier" le TreeSet : Copie du TreeSet dans une autre variable, "clear" du TreeSet, puis "addAll" sur le TreeSet avec en paramètre la sauvegarde.

Quelqu'un a t-il une/plusieurs idée(s) plus propre(s) que celles-ci ?

[dingoth]

Ta demande est simple dans les termes, mais difficile à mettre en place. L'idéal est d'avoir un objet (celui à trier) qui peut être écouté, pour savoir quand il est modifié.

Tu crées une classe Set pouvant accueillir un TreeSet, et étendant java.bean.PropertyListener.

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
public class MonObjet {
  public void addPropertyListener (PropertyListener listener) {
    ...
  }
  public void removePropertyListener (PropertyListener listener) {
 
  }
}
public class MonSet<E> extends AbstractSortedSet<E> implements java.bean.PropertyListener {
  private SortedSet<E> wrapped;
  private String propertyToListen;
 
  public boolean add(E e) {
    if (e!=null)
      e.addPropertyListener(this);
    return wrapped.add(e);
  }
 
  public boolean remove (E e) {
    if (e != null)
      e.removePropertyListener(this);
    return wrapped.remove(e);
  }
 
  public void sort () {
    this.wrapped = new TreeSet(wrapped);
  }
 
  public void propertyChanged (PropertyChangedEvent e) {
    if (propertyToListen != null && propertyToListen.equals(e.getPropertyName()) {
      sort();
    }
  }
}

À toi de continuer le code.

L'avantage, c'est que là, tu peux utiliser MonSet comme un Set complet et ne plus avoir à te soucier de rien.

L'inconvénient, c'est qu'à chaque modification d'un objet, un TreeSet est créé (et ça bouffe aussi bien du temps que de la mémoire).

[teletexte]

Merci pour cette réponse. Le problème est celui que tu as souligné, c'est à dire que cette solution est couteuse en espace et en temps. Le problème est non négligeable dans mon cas, puisqu'il s'agit d'éléments liés à une interface graphique. Plus clairement, chaque élément a une représentation graphique, et une modification graphique entraine une voir plusieurs modification de l'ensemble. Pour ma part je songe sérieusement à changer mes TreeSets par des ArrayLists dont j'aurai pris soin de redéfinir les méthodes add et addAll. Cette solution reste tout de même couteuse en temps : une recherche d'appartenance + un ajout + un tri Quelqu'un a t-il une autre suggestion ?