Discussion :

[coquero]

Bonjour,

SVP,j'ai une hashMap dont j'aimerais ordonner ces éléments de la clef qui a la valeur maximale jusqu'ai la minimale mais j'aboutis pas en plus j'arrive pas à afficher les clefs et les valeurs.

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
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
<
 
import java.util.*;
import java.io.*;
/**
Cette classe reçoit plusieurs listes de souhaits 
et construit la programmation optimale
*/
public class Optimiseur{
 
 
static List<String> listeReelle=new ArrayList<String>();
 
 
/**
Cette Map contient tous les clips avec leurs nombres de vote(nombre d'occurence dans la ligne de saisie)
*/
static Map<String,Integer> mapListePrioritaire=new HashMap<String,Integer>();
 
/**
Cette méthode parcourt les clips saisis par un utilisateur donné et les mets dans une liste  avant de faire appel
à la méthode nombreDeVoteParClip
*/
 
public static List<String> receptionListeClip(String[] tabClipsSaisis){
 
	for(int i=0;i<tabClipsSaisis.length && (tabClipsSaisis[i]) !=null;i++){
	listeReelle.add(tabClipsSaisis[i]);
	System.out.println("liste est:"+ "\t" + tabClipsSaisis[i]);
 
}
return listeReelle;
}
 
	/**
        Cette méthode calcul le nombre d'occurence de clip parmis tous les clips déjà saisis par les autres utilisateurs.
        la variable nombreVote commence à 1 car on ne fait appel à cette méthode que si le clip en question est saisi.
        Dans cette méthode,on alimente la listePrioritaire par le clip et son nombre de vote
        */
public static void nombreDeVoteParClip(String clip){
	int nombreVote=1;
	try{
	while(listeReelle !=null){
	for(int k=0;k<listeReelle.size();k++){
 
	if(listeReelle.get(k).equals(clip)) 
	{
	++(nombreVote);
 
	}
	mapListePrioritaire.put((listeReelle.get(k)),new Integer(nombreVote));
	}
 
 
	}
 
	}catch(NullPointerException npe){
	//npe.printStackTrace();
	}
	}
 
 
 
public static void main(String[] args){
 
 
 
	ArrayList<List> collectionToutesListesClips=new ArrayList<List>();
 
	try{
	BufferedReader	stdin = new BufferedReader(new InputStreamReader(System.in));
	Collection<Integer> values=null;
	int i=0;
	while(  (i++ < 2)){
	System.out.print("veuillez entrer votre numero d'utilisateur>> ");
	String numUtilisateur = stdin.readLine();
	System.out.print("veuillez entrer votre choix de clips> ");
	String choixClips=stdin.readLine();
	String [] clipsDemandesSurLigneCommande = choixClips.split(";");
	for(int h=0;h<listeReelle.size();h++)
	{
	listeReelle.addAll((Collection<String>)Optimiseur.receptionListeClip(clipsDemandesSurLigneCommande));
	Optimiseur.nombreDeVoteParClip(clipsDemandesSurLigneCommande[h]);
 
     }
	 System.out.println("etape1");
 
	 System.out.println("etape2");
 
 
 
	//if(maListePrioritaire.equals(null)) System.out.println("désolé");
 
}
	Set cles = mapListePrioritaire.keySet();
 
	Iterator it = cles.iterator();
	while (it.hasNext()){
	 System.out.println("etape22");
	Object cle =it.next(); 
	 System.out.println("etape23");
	Object valeur =mapListePrioritaire.get(cle); 
 
 
	 System.out.println("etape3");
 
	System.out.println("le clip est :" + (String)cle + "\t" + "la valeur est:" + "\t" +(Integer) valeur);
 
	}
 
 
}
 
	catch(IOException ioe){}
 
}
}
>

[thelvin]

Je n'ai pas envie de regarder les détails du programme, le problème n'est pas assez isolé du reste.

Si ça peut t'aider, sache qu'un HashMap n'est pas ordonné, jamais. Les éléments sont parcourus dans un ordre imprévisible, toujours.

Donc, pour ordonner suivant le nombre de votes, tu vas devoir prendre ta map et la convertir en autre chose, sur lequel on pourra faire un tri.

Je propose de
- définir une classe ClipVotes qui contient le nom du clip et son nombre de votes.
- Créer une ArrayList<ClipVotes> de la taille de la map.
- Parcourir la map, et pour chaque élément, créer un ClipVotes et le mettre dans la liste.
- Utiliser Collections.sort() sur la liste, en définissant un Comparator<ClipVotes> qui compare suivant le nombre de vote.

en plus j'arrive pas à afficher les clefs et les valeurs.

Bah si, tu l'as fait !

[Fmunch]

Effectivement je n'ai pas une grande envie de lire ton code, je règlerais ton problème de la façon suivante :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Map<Integer, String> map = new HashMap<Integer, String>();
map.put(new Integer(1),"Bonjour");
map.put(new Integer(2),"Salutations");
map.put(new Integer(3),"Avions");
map.put(new Integer(4),"Aviron");
Map.Entry<Integer,String>[] array = map.entrySet().toArray(new Map.Entry[map.size()]);
 
Arrays.sort(array, new Comparator<Map.Entry<Integer,String>>() {
        public int compare(Map.Entry<Integer,String> a1, Map.Entry<Integer,String> a2) {
                return a1.getValue().compareTo(a2.getValue()); // en supposant que les valeurs soient comparable.
        }
});
System.out.println(Arrays.toString(array));

D'autre part tu remarquera que l'on a pas pu spécifier de type générique lors de la création du tableau.

[Fmunch]

Si tu veux inverser l'ordre tu échange a1 et a2.

Si tu accède souvent à ces données par les clés, je te conseille de crée une seconde Map à côté qui permet cette accès, et d'utiliser une TreeMap : elle est trié, tu pourras alors très facilement accéder dans l'ordre que tu souhaite.

[Fmunch]

Tu pourrais aussi utiliser une file de priorité de taille fini : quand elle atteint un taille trop importante tu enlève l'élément le plus grand.