Hashtable, trie et doublon

Version imprimable

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:

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.

01/03/2016, 17h46
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.
01/03/2016, 17h53
mazertys17

Ok, merci, Dinobogan.

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

Salut,

Tu peux utiliser une TreeMap par exemple.

Code:

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

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

Code:

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:

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

Avec :

Code:

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:

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;
 
      }
}

Citation:

Envoyé par mazertys17

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:

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:

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(); }

02/03/2016, 08h44
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.