wake-up-neo.com

Sortieren der Karte <Schlüssel, Wert> in absteigender Reihenfolge basierend auf dem Wert

Mögliches Duplikat:
Wie sortiere ich eine Map <Schlüssel, Wert> nach den Werten in Java?

Ich verwende die Kartenschnittstelle, um aus einer Datei zu lesen und die Werte darin als Schlüsselwertpaar zu speichern. Das Dateiformat ist wie folgt

 A 34
 B 25
 c 50

Ich lese die Daten aus dieser Datei und speichere sie als Schlüsselwertpaar und zeige sie dann dem Benutzer an. Meine Anforderung ist es, die Ergebnisse in diesem Format anzuzeigen

C 50
A 34
B 25

Daher muss ich die Karte in absteigender Reihenfolge des Werts sortieren. Damit ich diese als mein Ergebnis anzeigen kann. Ich habe darüber gelesen und finde den folgenden Code

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

Ich hoffe, dies sortiert die Werte in aufsteigender Reihenfolge. Ich möchte nur wissen, ob dieser Ansatz korrekt ist oder ein anderer effektiver Ansatz für mich hilfreich ist.

29
NandaKumar

Da Sie doppelte Werte haben können, sollten Sie überhaupt kein Set verwenden. Ändern Sie in ein List und sortieren Sie es stattdessen. Ihr entriesSortedByValues würde ungefähr so ​​aussehen:

static <K,V extends Comparable<? super V>> 
            List<Entry<K, V>> entriesSortedByValues(Map<K,V> map) {

    List<Entry<K,V>> sortedEntries = new ArrayList<Entry<K,V>>(map.entrySet());

    Collections.sort(sortedEntries, 
            new Comparator<Entry<K,V>>() {
                @Override
                public int compare(Entry<K,V> e1, Entry<K,V> e2) {
                    return e2.getValue().compareTo(e1.getValue());
                }
            }
    );

    return sortedEntries;
}

Hinweis: In Ihrer Beispielausgabe sind die Werte absteigend. Wenn Sie möchten, dass sie aufsteigend sind, verwenden Sie stattdessen e1.getValue().compareTo(e2.getValue()).


Beispiel:

public static void main(String args[]) {

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("A", 34);
    map.put("B", 25);
    map.put("C", 50);
    map.put("D", 50); // "duplicate" value

    System.out.println(entriesSortedByValues(map));
}

Ausgabe:

[D=50, C=50, A=34, B=25]
48
dacwe

Schreiben Sie Ihr eigenes comparator und übergeben Sie es an TreeMap

class MyComparator implements Comparator {

Map map;

public MyComparator(Map map) {
    this.map = map;
}

public int compare(Object o1, Object o2) {

    return ((Integer) map.get(o2)).compareTo((Integer) map.get(o1));

}
}

In der Testklasse

Map<String, Integer> lMap=new HashMap<String, Integer>();
    lMap.put("A", 35);
    lMap.put("B", 25);
    lMap.put("C", 50);

    MyComparator comp=new MyComparator(lMap);

    Map<String,Integer> newMap = new TreeMap(comp);
    newMap.putAll(lMap);

OutPut:

C=50
A=35
B=25
13
amicngh