Wie sortiert man Map-Werte nach Schlüssel in Java?

Question

Ich habe eine Map, die Zeichenfolgen für Schlüssel und Werte hat.

Daten sind wie Folgendes:

"Frage1", "1"
"Frage9", "1"
"Frage2", "4"
"Frage5", "2"

Ich möchte die Karte anhand ihrer Schlüssel sortieren. Am Ende werde ich also Folgendes haben question1, question2, question3 ....und so weiter.

Letztendlich versuche ich, zwei Stränge aus dieser Karte herauszuholen.

• Erste Saite: Fragen (in der Reihenfolge 1 ..10)
• Zweite Saite: Antworten (in der gleichen Reihenfolge wie die Frage)

Im Moment habe ich Folgendes:

Iterator it = paramMap.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry pairs = (Map.Entry) it.next();
    questionAnswers += pairs.getKey() + ",";
}

So erhalte ich die Fragen in einer Reihe, aber sie sind nicht in der richtigen Reihenfolge.

Answer 1

Wenn Sie bereits eine Karte haben und sie nach Schlüsseln sortieren möchten, verwenden Sie einfach :

Map<String, String> treeMap = new TreeMap<String, String>(yourMap);

Ein vollständiges Arbeitsbeispiel :

import java.util.HashMap;
import java.util.Set;
import java.util.Map;
import java.util.TreeMap;
import java.util.Iterator;

class SortOnKey {

public static void main(String[] args) {
   HashMap<String,String> hm = new HashMap<String,String>();
   hm.put("3","three");
   hm.put("1","one");
   hm.put("4","four");
   hm.put("2","two");
   printMap(hm);
   Map<String, String> treeMap = new TreeMap<String, String>(hm);
   printMap(treeMap);
}//main

public static void printMap(Map<String,String> map) {
    Set s = map.entrySet();
    Iterator it = s.iterator();
    while ( it.hasNext() ) {
       Map.Entry entry = (Map.Entry) it.next();
       String key = (String) entry.getKey();
       String value = (String) entry.getValue();
       System.out.println(key + " => " + value);
    }//while
    System.out.println("========================");
}//printMap

}//class

Answer 2

Vorausgesetzt, Sie können TreeMap , in Java 8 können wir nutzen toMap() Methode in Collectors die folgende Parameter benötigt:

• keymapper : Mapping-Funktion zur Erzeugung von Schlüsseln
• valuemapper : Mapping-Funktion zur Erzeugung von Werten
• mergeFunction : eine Zusammenführungsfunktion, die dazu dient Kollisionen zwischen Werten aufzulösen, die mit demselben Schlüssel verbunden sind
• mapSupplier : eine Funktion, die eine neue, leere Map zurückgibt, in die die Ergebnisse eingefügt werden.

Java 8 Beispiel

Map<String,String> sample = new HashMap<>();  // push some values to map  
Map<String, String> newMapSortedByKey = sample.entrySet().stream()
                    .sorted(Map.Entry.<String,String>comparingByKey().reversed())
                    .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));
Map<String, String> newMapSortedByValue = sample.entrySet().stream()
                        .sorted(Map.Entry.<String,String>comparingByValue().reversed())
                        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));

Wir können das Beispiel ändern, um einen benutzerdefinierten Komparator zu verwenden und nach Schlüsseln zu sortieren:

Map<String, String> newMapSortedByKey = sample.entrySet().stream()
                .sorted((e1,e2) -> e1.getKey().compareTo(e2.getKey()))
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1,e2) -> e1, LinkedHashMap::new));

Answer 3

使用方法 Java 8:

Map<String, Integer> sortedMap = unsortMap.entrySet().stream()
            .sorted(Map.Entry.comparingByKey())
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue,
                    (oldValue, newValue) -> oldValue, LinkedHashMap::new));

Answer 4

In Java 8

Zum Sortieren einer Map<K, V> nach Schlüssel, wobei die Schlüssel in eine List<K> :

List<K> result = map.keySet().stream().sorted().collect(Collectors.toList());

Zum Sortieren einer Map<K, V> nach Schlüssel, wobei die Einträge in einem List<Map.Entry<K, V>> :

List<Map.Entry<K, V>> result =
    map.entrySet()
       .stream()
       .sorted(Map.Entry.comparingByKey())
       .collect(Collectors.toList());

Last but not least: Sortieren Zeichenketten in einer ortsabhängigen Weise - verwenden Sie eine Kollator (Komparator) Klasse:

Collator collator = Collator.getInstance(Locale.US);
collator.setStrength(Collator.PRIMARY); // case insensitive collator

List<Map.Entry<String, String>> result =
    map.entrySet()
       .stream()
       .sorted(Map.Entry.comparingByKey(collator))
       .collect(Collectors.toList());

Answer 5

Dieser Code kann eine Key-Value-Map in beiden Reihenfolgen sortieren, d. h. aufsteigend und absteigend.

<K, V extends Comparable<V>> Map<K, V> sortByValues
     (final Map<K, V> map, int ascending)
{
     Comparator<K> valueComparator =  new Comparator<K>() {         
        private int ascending;
        public int compare(K k1, K k2) {
            int compare = map.get(k2).compareTo(map.get(k1));
            if (compare == 0) return 1;
            else return ascending*compare;
        }
        public Comparator<K> setParam(int ascending)
        {
            this.ascending = ascending;
            return this;
        }
    }.setParam(ascending);

    Map<K, V> sortedByValues = new TreeMap<K, V>(valueComparator);
    sortedByValues.putAll(map);
    return sortedByValues;
}

Ein Beispiel:

Map<Integer,Double> recommWarrVals = new HashMap<Integer,Double>();
recommWarrVals = sortByValues(recommWarrVals, 1);  // Ascending order
recommWarrVals = sortByValues(recommWarrVals,-1);  // Descending order