Discussion :

[mazertys17]

Bonjour.

J'aimerais utiliser une Hashtable pour trier des object en fonction d'une valeur :

ex :

j'ai un objet qui est accolé a la valeur 2, puis un autre la valeur 4, puis un autre valeur 4 encore, puis un 5, puis un 2 etc...

Le but est d'avoir accès a tous les objets par ordre croissant de cette valeur accolé, tout en gardant les doublons.

Je procède ainsi, mais le resultat est mauvais puisqu'il semblerait qu'il ne me renvoi qu'une petite partie des objets :

Code :

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

1
2
3
4
5
6
7
8
9
 
 
        Hashtable<Integer, Object> select = new Hashtable<Integer, Object>();
 
        select.put( number , listID.get(cont3));
 
    for (Map.Entry<Integer, Object> entry : select.entrySet()){
        entry.getValue().doJob();
    }

Or si "number " est croissant, toujours différents, tous les objets sont bien sélectionnés.

Il y a-t-il une methode particulière pour faire ceci ?

Merci si vous pouvez m'aider.

[dinobogan]

De manière générale, trier par Hashtable est une mauvaise idée.
Le seul cas ou c'est intéressant, c'est lorsque les clés ont une répartition selon une suite continue (ou sans trop de trous).
Un tri par Hashtable se déroule en deux étapes :

1. insérer les couples clé/valeur
2. prendre la valeur de clé la plus basse puis incrémenter la clé en vérifiant son existence dans la table

Ce qui peut devenir extrêmement couteux, c'est le parcours des clés.

Ton code ne peux pas fonctionner puisque tu parcours les entrées de la table qui n'ont aucune notion d'ordre. Donc ta boucle for parcourt les données de la table dans le désordre.

[mazertys17]

Ok, merci, Dinobogan.

Connais tu par hasard un conteneur approprié a mon cas ?

[joel.drigo]

Salut,

Tu peux utiliser une TreeMap par exemple.

Code :

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

TreeMap<Integer, List<Object>> map = new TreeMap<>();

Pour écrire tes valeurs, tu peux procéder à l'ancienne (Java 7 et précédent) :

Code :

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

1
2
3
4
5
6
7
8
void ajouterObject(int cle, Object object) {
       List<Object> list = map.get(cle);
       if ( list==null ) {
            list = new ArrayList<>();
            map.put(cle, list);
       }
       list.add(object);
}

ou en Java 8 :

Code :

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

1
2
3
4
5
void ajouterObject(int cle, Object object) {
 
        map.compute(cle, Utils.toListMappingFunction(object));
 
}

Avec :

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
public class Utils {
        public static <K, T> BiFunction<K,List<T>,List<T>> toListMappingFunction(T t) {
		return toListMappingFunction(t, ()-> new ArrayList<>());
	}
 
	public static <K, T> BiFunction<K,List<T>,List<T>> toListMappingFunction(T t, Supplier<List<T>> supplier) {
		return new BiFunction<K, List<T>, List<T>>() {
			public List<T> apply(K k, List<T> v) {
				if ( v==null ) {
					v = supplier.get();
				}
				v.add(t);
				return v;
			}
		};
	}
}

Pour le parcourt :

Code :

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

1
2
3
4
5
6
7
8
for(Map.Entry<Integer, List<Object>> entry : map.entrySet()) {
              System.out.println("Clé : " + entry.getKey());
      for(Object object : entry.getValue()) {
 
              System.out.println("      Valeur : " + object;
 
      }
}

[tchize_]

j'ai un objet qui est accolé a la valeur 2, puis un autre la valeur 4, puis un autre valeur 4 encore, puis un 5, puis un 2 etc...

Le but est d'avoir accès a tous les objets par ordre croissant de cette valeur accolé, tout en gardant les doublons.


Il y a-t-il une methode particulière pour faire ceci ?

Merci si vous pouvez m'aider.

Le plus simple ca reste de créer un objet dédié à ton tri, tout simplement

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class WeightedObject<T> implements Comparable<WeightedObject<T>>{7
   private Integer value;
   private T object;
   public WeightedObject (T object, int value){
      this.object = object;
      this.value = value;
   }
  public int compareTo(WeightedObject<T>  other){
      return value.compareTo(other.value);
  }
   // + getters & setters
}

Code :

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

1
2
3
4
5
6
7
8
List<WeightedObject<TonType>> taListe = ...
taListe.add(new WeightedObject<TonType>(x,1));
taListe.add(new WeightedObject<TonType>(y,4));
taListe.add(new WeightedObject<TonType>(z,1));
Collections.sort(taListe);
for (WeightedObject<TonType> w: taListe){
    w.getObject().doJob();
}

[MathiasSeguy]

Sur Android, on préconise l'utilisation des sparseArray dès que la clef est de type primitif (int, double,...). Il existe un sparseArray spécifique par use case. C'est ce que tu devrais utiliser si tu fais de l'Android.