Discussion :

[Raikyn]

Bonjour,

J'ai le code suivant :

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
 
public static <K, V extends Comparable<? super V>> Map<K, V> 
				sortByValue( Map<K, V> map )
    {
        List<Map.Entry<K, V>> list =
            new LinkedList<Map.Entry<K, V>>( map.entrySet() );
        Collections.sort( list, new Comparator<Map.Entry<K, V>>()
        {
            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )
            {
                return (o1.getValue()).compareTo( o2.getValue() );
            }
        } );
	List<Map.Entry<K, V>> list2 = Collection.reverse(list);
 
        Map<K, V> result = new LinkedHashMap<K, V>();
        for (Map.Entry<K, V> entry : list)
        {
            result.put( entry.getKey(), entry.getValue() );
        }
        return result;
    }

Cela trie une HashMap (suivant la valeur) dans l'ordre croissant. Ce code n'est pas de moi, je l'ai trouvé sur le net.
Je ne suis pas familier avec les Collection mais il semblerait que pour faire le trie d'une hashMap, ce code met le contenu de la hashMap dans une List pour ensuite trier la List (et renvoyer une hashMap à partir de cette List).
J'aimerai trier dans un ordre décroissant, comment faire ?
J'ai essayer :

Code :

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

Collection.reverse(list)

mais cela ne marche pas.
Auriez vous une solution ?

Merci d'avance pour votre aide.

[joel.drigo]

Salut,

Collections.reverse(liste) c'est pour inverser l'ordre actuel des éléments dans la liste : ça ne trie rien du tout. Le code que tu as pris trie les entrées de la map (association clef/valeurs) selon les valeurs, puis inverse la liste triées de ces entrées puis les range dans une LinkedHashMap pour conserver cet ordre (parce qu'une simple HashMap ne conserve pas l'ordre).

La ligne qui fait le tri est :

Code :

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

1
2
3
4
5
6
7
Collections.sort( list, new Comparator<Map.Entry<K, V>>()
        {
            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )
            {
                return (o1.getValue()).compareTo( o2.getValue() );
            }
        } );

On peut se demander pourquoi on tri dans un ordre puis on inverse l'ordre, plutôt que de trier dans le bon ordre dès le départ ?



Toujours est-il qu'on utilise Collections.sort(list) ou Collections.sort(liste, comparator) : le premier pour trier des éléments qui ont un ordre naturel (soit qui implémente l'interface Comparable), comme des String, des Integer, des Dates.
Pour les autres, il faut utiliser la seconde version et implémenter un Comparator qui dira justement quel est l'ordre entre 2 éléments, quels qu'ils soient.

Pour trier dans l'ordre inverse de l'ordre naturel, il faut donc utiliser un comparator : mais il existe déjà, tu n'as pas besoin de l'implémenter. Tu peux l'obtenir par Collections.reverseOrder().

Par exemple pour trier une liste d'entiers (ou de tout autre Comparable) dans l'ordre inverse de l'ordre naturel, donc décroissant pour les entiers, entre autres :

Code :

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

  Collections.sort( liste, Collections.reverseOrder() );

Ou en Java 8, plus logiquement peut-être :

Code :

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

  Collections.sort( liste, Comparator.reverseOrder() );

[Raikyn]

Donc il faudrait que je remplace le tri :

Code :

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

1
2
3
4
5
6
7
Collections.sort( list, new Comparator<Map.Entry<K, V>>()
        {
            public int compare( Map.Entry<K, V> o1, Map.Entry<K, V> o2 )
            {
                return (o1.getValue()).compareTo( o2.getValue() );
            }
        } );

Par:

Code :

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

Collections.sort( liste, Collections.reverseOrder() );

Le truc c'est que reverseOrder() n'est pas une méthode de Collection ou Comparato, ça ne compile pas.

[joel.drigo]

Pas de Collection, de Collections ou de Comparator, à partir de Java 8.

[Raikyn]

Ah d'accord!
Bon alors ça compile mais j'ai une erreur à l'execution :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Exception in thread "main" java.lang.ClassCastException: java.util.HashMap$Entry cannot be cast to java.lang.Comparable
	at java.util.Collections$ReverseComparator.compare(Collections.java:3569)
	at java.util.TimSort.countRunAndMakeAscending(TimSort.java:324)
	at java.util.TimSort.sort(TimSort.java:203)
	at java.util.TimSort.sort(TimSort.java:173)
	at java.util.Arrays.sort(Arrays.java:659)
	at java.util.Collections.sort(Collections.java:217)
	at Zipf.sortByValue(Zipf.java:97)
	at Zipf.<init>(Zipf.java:17)
	at Interface.<init>(Interface.java:19)
	at Interface.main(Interface.java:95)

[joel.drigo]

Mais c'est une List (le titre de ta discussion) ou une Map que tu cherches à trier ? Comment ça se fait que tu tries des Map.Entry ?