Discussion :

[Rony Rauzduel]

Bonjour,

Je voudrai utiliser la méthode compare de l'interface comparator de java.util afin d'effectuer un tri sur les valeurs en fonction des clés d'une SortedMap (car le tri s'effectue sur l'ordre naturel des clés).
J'ai le code suivant :

Code java :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
private static void compareMapValues(Map<Integer,String> map) {
        synchronized (map) {
            Collections.synchronizedSortedMap(
                    new TreeMap<>(new Comparator() {
                        @Override
                        public int compare(Object o1, Object o2) {
                            return 0;
                        }
                    })
            );
        }
    }

Par contre lorsque je change les attributs de la méthode compare(Integer o1, Integer o2) l'IDE me dit que je dois implémenter la méthode compare initiale.
Dois-je redéfinir cette méthode pour effectuer ma comparaison?

Merci par avance.
Transact.

[adiGuba]

Salut,


Il faut surtout paramétrer la classe anonyme :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
	private static void compareMapValues(Map<Integer,String> map) {
        synchronized (map) {
            Collections.synchronizedSortedMap(
                    new TreeMap<>(new Comparator<Integer>() {
                        @Override
                        public int compare(Integer o1, Integer o2) {
                            return 0;
                        }
                    })
            );
        }
    }

a++

[thelvin]

Hello,

Comparator est une classe générique. Il faut faire new Comparator<Integer>() et non pas juste new Comparator()

Par contre, je ne vois pas bien quel ordre tu veux utiliser sur des Integer si ce n'est pas l'ordre naturel. Et en Java 1.8, il est plus pratique d'utiliser des lambdas plutôt que créer explicitement une implémentation anonyme de Comparator :

Code :

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

Map<Integer, String> map = new TreeSet<>((i1, i2) -> i1 - i2);

[Rony Rauzduel]

En effet ce serait davantage la signature suivante :

Code java :

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

1
2
3
4
5
6
7
8
9
 
Collections.synchronizedSortedMap(
                        new TreeMap<>(new Comparator<String>() {
                            @Override
                            public int compare(String o1, String o2) {
                                return o1.compareTo(o2);
                            }
                        })
                );

[Rony Rauzduel]

Par contre le tri ordonnée ne se fait pas.

[thelvin]

Avec ton code, tu crées une superbe SortedMap<String, NIMPORTEQUOI> vide, qui triera ses futures clés avec le comparator donné, et dont les accès multithreadés seront synchronisés.

... Et après avoir créé cette SortedMap vide, tu n'en fais rien et tu la laisses reprendre par le garbage collector.
C'était quoi l'idée ? À quoi sert le paramètre map ? Et le fait de se synchroniser dessus ? Comment sais-tu que le tri ne se fait pas, puisqu'elle ne contient jamais d'élément et qu'il n'y a jamais rien à trier ?

[Rony Rauzduel]

L'idée est de passer une map en paramètre de ma méthode et que mon comparateur effectue un tri ordonné des valeurs de cette map.
Je décide de synchroniser cette map afin d'eviter les accès concurentiels ... pour la suite de mon exercice.

[thelvin]

Mbon, et une fois qu'on a trié ces données, est-ce qu'il y a volonté de faire quelque chose avec ? Parce que la méthode renvoie void, là. Je suppose qu'on ne trie pas pour la beauté du geste.

[adiGuba]

L'idée est de passer une map en paramètre de ma méthode et que mon comparateur effectue un tri ordonné des valeurs de cette map.

Ce n'est pas du tout ce que fait ton code... puisque tu crées une nouvelle map que tu n'utilises pas.

Et on ne peut pas trier les clefs d'un Map.
Les clefs des maps ne sont pas forcément trié. Cela dépend de l'implémentation de la Map.

Bref c'est quelque chose à définir lors de la création de la Map, pas après...


a++

[Rony Rauzduel]

Entendu, je vais revoir la conception de mon code pour l'imlémentation de la Map.
je me suis penché sur l'utilisation de l'interface Comparator de l'API Java, je vous transmets l'intégralité de mon code. Cependant le tri ne s'effectue toujours pas sur les valeurs.

Code java :

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
 
public class Main {
    public final static int NB_FRUITS = 10;
 
    /**
     * Note : This method allows you to sort a Map by values against by keys
     * We have to used a compare method of Comparator interface to realize it.
     *
     * @param map the map that we want to sort by values
     * @param <K> the type of keys maintained by this map
     * @param <V> the type of mapped values
     * @return A Map sort by values, so a SortedMap but sort by values
     */
    public static <K, V extends Comparable<V>> Map<K, V> sortByValues(final Map<K,V> map) {
        Comparator<K> valueComparator = new Comparator<K>() {
            @Override
            public int compare(K o1, K o2) {
                int compare = map.get(o1).compareTo(map.get(o2));
                if(compare == 0)
                    return 1;
                else
                    return compare;
            }
        };
        Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
        sortedByValues.putAll(map);
        return sortedByValues;
    }
 
    public static void buildMap(Map<Integer,String> map) {
        String fruit;
        for (int i = 0; i < NB_FRUITS; i++) {
            fruit = TextIO.getlnString(); // replace Scanner class
            map.put(i,fruit);
        }
    }
 
    public static void displayMap(Map<Integer,String> map) {
        for (Map.Entry<Integer,String> fruit :  map.entrySet()) {
            System.out.println(fruit.getKey() + " : " + fruit.getValue());
        }
    }
 
    public static void main(String[] args) {
        TreeMap<Integer, String> tMap = new TreeMap<>();
        System.out.println("Please enter a fruit name in your basket : ");
        buildMap(tMap);
        sortByValues(tMap);
        displayMap(tMap);
    }
}

[adiGuba]

En même temps tu ne récupères pas le retour de la méthode sortByValue(), donc l'appel ne sert à rien !
Tu crées des objets mais tu ne les utilises pas...

Encore une fois le Comparator doit être spécifié à la création de la Map, pas après...


De plus tu ne peux pas trier les éléments par valeurs, mais uniquement par clef.
Ton code risque de poser divers problèmes dans de nombreux cas...


a++

[joel.drigo]

Salut,

On se moque du tri d'un map, tant qu'on s'en sert pour récupérer des valeurs par leur clef. Avoir des données triées ne sert que lorsqu'on les parcourt : pourquoi ne pas trier l'entryset dans ce cas, au moment du parcours ?

[Rony Rauzduel]

Merci pour la pertinence de vos retours. Je reconnais qu'il est tout à fait "illogique" du point de vue fonctionnel de trier une Map par valeur.
D'où la réponse d'Adiguba

De plus tu ne peux pas trier les éléments par valeurs, mais uniquement par clef.

Je parviens à récupérer le tri par valeur, en récupérant le retour de la méthode sortedByValues() et en l'affichant avec la méthode display

Code java :

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

1
2
3
4
5
6
7
8
 
 public static void main(String[] args) {
        TreeMap<Integer, String> tMap = new TreeMap<>();
        System.out.println("Please enter a fruit name in your basket : ");
        buildMap(tMap);
        Map<Integer, String> m = sortByValues(tMap);
        displayMap(m);
    }

Merci encore et bonne journée.
Transact.