TreeMap trier par valeur

Je veux écrire un comparateur qui me permettra de trier un TreeMap par valeur au lieu de l'ordre naturel par défaut.

J'ai essayé quelque chose comme ça, mais je ne trouve pas ce qui ne va pas:

import java.util.*;

class treeMap {
    public static void main(String[] args) {
        System.out.println("the main");
        byValue cmp = new byValue();
        Map<String, Integer> map = new TreeMap<String, Integer>(cmp);
        map.put("de",10);
        map.put("ab", 20);
        map.put("a",5);

        for (Map.Entry<String,Integer> pair: map.entrySet()) {
            System.out.println(pair.getKey()+":"+pair.getValue());
        }
    }
}

class byValue implements Comparator<Map.Entry<String,Integer>> {
    public int compare(Map.Entry<String,Integer> e1, Map.Entry<String,Integer> e2) {
        if (e1.getValue() < e2.getValue()){
            return 1;
        } else if (e1.getValue() == e2.getValue()) {
            return 0;
        } else {
            return -1;
        }
    }
}

Je suppose que ce que je demande est: puis-je obtenir un Map.Entrypassage au comparateur?

Vous ne pouvez pas avoir le TreeMaptri lui - même sur les valeurs, car cela défie la SortedMapspécification:

Un Mapqui assure en outre une commande totale sur ses clés .

Cependant, en utilisant une collection externe, vous pouvez toujours trier Map.entrySet() comme vous le souhaitez, soit par clés, valeurs, ou même une combinaison (!!) des deux.

Voici une méthode générique qui retourne a SortedSetof Map.Entry, étant donné a Mapdont les valeurs sont Comparable:

static <K,V extends Comparable<? super V>>
SortedSet<Map.Entry<K,V>> entriesSortedByValues(Map<K,V> map) {
    SortedSet<Map.Entry<K,V>> sortedEntries = new TreeSet<Map.Entry<K,V>>(
        new Comparator<Map.Entry<K,V>>() {
            @Override public int compare(Map.Entry<K,V> e1, Map.Entry<K,V> e2) {
                int res = e1.getValue().compareTo(e2.getValue());
                return res != 0 ? res : 1;
            }
        }
    );
    sortedEntries.addAll(map.entrySet());
    return sortedEntries;
}

Vous pouvez maintenant effectuer les opérations suivantes:

    Map<String,Integer> map = new TreeMap<String,Integer>();
    map.put("A", 3);
    map.put("B", 2);
    map.put("C", 1);   

    System.out.println(map);
    // prints "{A=3, B=2, C=1}"
    System.out.println(entriesSortedByValues(map));
    // prints "[C=1, B=2, A=3]"

Notez que des trucs géniaux se produiront si vous essayez de modifier soit le SortedSetlui - même, soit l' Map.Entryintérieur, car ce n'est plus une "vue" de la carte originale comme l' entrySet()est.

D'une manière générale, la nécessité de trier les entrées d'une carte par ses valeurs est atypique.

Remarque sur ==pourInteger

Votre comparateur d'origine compare en Integerutilisant ==. C'est presque toujours faux, car ==avec les Integeropérandes est une égalité de référence, pas une égalité de valeur.

    System.out.println(new Integer(0) == new Integer(0)); // prints "false"!!!

Questions connexes

• Lors de la comparaison de deux entiers en Java, le déballage automatique se produit-il?(NON!!!)
• Est-il garanti que new Integer(i) == idans Java? (OUI!!!)

La réponse des lubrifiants polygéniques est presque parfaite. Il a cependant un bug important. Il ne gérera pas les entrées de mappage dont les valeurs sont identiques.

Ce code: ...

Map<String, Integer> nonSortedMap = new HashMap<String, Integer>();
nonSortedMap.put("ape", 1);
nonSortedMap.put("pig", 3);
nonSortedMap.put("cow", 1);
nonSortedMap.put("frog", 2);

for (Entry<String, Integer> entry  : entriesSortedByValues(nonSortedMap)) {
    System.out.println(entry.getKey()+":"+entry.getValue());
}

Produirait:

ape:1
frog:2
pig:3

Remarquez comment notre vache a disparu en partageant la valeur «1» avec notre singe: O!

Cette modification du code résout ce problème:

static <K,V extends Comparable<? super V>> SortedSet<Map.Entry<K,V>> entriesSortedByValues(Map<K,V> map) {
        SortedSet<Map.Entry<K,V>> sortedEntries = new TreeSet<Map.Entry<K,V>>(
            new Comparator<Map.Entry<K,V>>() {
                @Override public int compare(Map.Entry<K,V> e1, Map.Entry<K,V> e2) {
                    int res = e1.getValue().compareTo(e2.getValue());
                    return res != 0 ? res : 1; // Special fix to preserve items with equal values
                }
            }
        );
        sortedEntries.addAll(map.entrySet());
        return sortedEntries;
    }

Dans Java 8:

LinkedHashMap<Integer, String> sortedMap = 
    map.entrySet().stream().
    sorted(Entry.comparingByValue()).
    collect(Collectors.toMap(Entry::getKey, Entry::getValue,
                             (e1, e2) -> e1, LinkedHashMap::new));

A TreeMapest toujours trié par les clés, tout le reste est impossible. A Comparatorvous permet simplement de contrôler comment les clés sont triées.

Si vous voulez les valeurs triées, vous devez les extraire dans un Listet les trier.

Cela ne peut pas être fait en utilisant a Comparator, car il obtiendra toujours la clé de la carte à comparer. TreeMapne peut trier que par clé.

La réponse d'Olof est bonne, mais il lui faut encore une chose avant d'être parfaite. Dans les commentaires ci-dessous sa réponse, dacwe souligne (correctement) que son implémentation viole le contrat Compare / Equals pour les Sets. Si vous essayez d'appeler contient ou de supprimer une entrée qui est clairement dans l'ensemble, l'ensemble ne la reconnaîtra pas en raison du code qui permet aux entrées de valeurs égales d'être placées dans l'ensemble. Donc, pour résoudre ce problème, nous devons tester l'égalité entre les clés:

static <K,V extends Comparable<? super V>> SortedSet<Map.Entry<K,V>> entriesSortedByValues(Map<K,V> map) {
    SortedSet<Map.Entry<K,V>> sortedEntries = new TreeSet<Map.Entry<K,V>>(
        new Comparator<Map.Entry<K,V>>() {
            @Override public int compare(Map.Entry<K,V> e1, Map.Entry<K,V> e2) {
                int res = e1.getValue().compareTo(e2.getValue());
                if (e1.getKey().equals(e2.getKey())) {
                    return res; // Code will now handle equality properly
                } else {
                    return res != 0 ? res : 1; // While still adding all entries
                }
            }
        }
    );
    sortedEntries.addAll(map.entrySet());
    return sortedEntries;
}

"Notez que l'ordre maintenu par un ensemble trié (qu'un comparateur explicite soit fourni ou non) doit être cohérent avec égal si l'ensemble trié doit implémenter correctement l'interface Set ... l'interface Set est définie en termes de l'opération d'égalité , mais un ensemble trié effectue toutes les comparaisons d'éléments en utilisant sa méthode compareTo (ou compare), de sorte que deux éléments jugés égaux par cette méthode sont, du point de vue de l'ensemble trié, égaux . " ( http://docs.oracle.com/javase/6/docs/api/java/util/SortedSet.html )

Comme nous avions à l'origine négligé l'égalité afin de forcer l'ensemble à ajouter des entrées de valeur égale, nous devons maintenant tester l'égalité dans les clés pour que l'ensemble renvoie réellement l'entrée que vous recherchez. C'est un peu compliqué et ce n'est certainement pas la façon dont les ensembles étaient censés être utilisés - mais cela fonctionne.

Je sais que cet article demande spécifiquement de trier un TreeMap par valeurs, mais pour ceux d'entre nous qui ne se soucient pas vraiment de la mise en œuvre mais qui veulent une solution qui garde la collection triée au fur et à mesure que les éléments sont ajoutés, j'apprécierais les commentaires sur ce TreeSet Solution. D'une part, les éléments ne sont pas facilement récupérés par clé, mais pour le cas d'utilisation que j'avais sous la main (trouver les n clés avec les valeurs les plus basses), ce n'était pas une exigence.

  TreeSet<Map.Entry<Integer, Double>> set = new TreeSet<>(new Comparator<Map.Entry<Integer, Double>>()
  {
    @Override
    public int compare(Map.Entry<Integer, Double> o1, Map.Entry<Integer, Double> o2)
    {
      int valueComparison = o1.getValue().compareTo(o2.getValue());
      return valueComparison == 0 ? o1.getKey().compareTo(o2.getKey()) : valueComparison;
    }
  });
  int key = 5;
  double value = 1.0;
  set.add(new AbstractMap.SimpleEntry<>(key, value));

Beaucoup de gens entendent qu'il est conseillé d'utiliser List et je préfère l'utiliser également

voici deux méthodes dont vous avez besoin pour trier les entrées de la carte en fonction de leurs valeurs.

    static final Comparator<Entry<?, Double>> DOUBLE_VALUE_COMPARATOR = 
        new Comparator<Entry<?, Double>>() {
            @Override
            public int compare(Entry<?, Double> o1, Entry<?, Double> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
        };

        static final List<Entry<?, Double>> sortHashMapByDoubleValue(HashMap temp)
        {
            Set<Entry<?, Double>> entryOfMap = temp.entrySet();

            List<Entry<?, Double>> entries = new ArrayList<Entry<?, Double>>(entryOfMap);
            Collections.sort(entries, DOUBLE_VALUE_COMPARATOR);
            return entries;
        }