Eine kurze Diskussion über Javas Map-Sortierung nach Wert (Map-Sortierung nach Wert)

Map ist eine Sammlung von Schlüssel-Wert-Paaren, auch Wörterbuch oder assoziatives Array usw. genannt. Es ist eine der häufigsten Datenstrukturen. Wie sortiere ich eine Karte nach Wert in Java? Es scheint einfach, aber es ist nicht einfach!

Zum Beispiel ist der Schlüssel in der Karte vom Typ String und stellt ein Wort dar, und der Wert ist vom Typ int und stellt die Häufigkeit dar, mit der das Wort vorkommt. Jetzt möchten wir nach der Häufigkeit sortieren das Wort erscheint:

Map map = new TreeMap();
map.put("me", 1000);
map.put("and", 4000);
map.put("you", 3000);
map.put("food", 10000);
map.put("hungry", 5000);
map.put("later", 6000);

Das Ergebnis der Sortierung nach Wert sollte sein:

key value
me 1000
you 3000
and 4000
hungry 5000
later 6000
food 10000

Zunächst die SortedMap-Struktur kann nicht verwendet werden, da SortedMap eine nach Schlüssel sortierte Karte ist, nicht eine nach Wert sortierte Karte. Was wir wollen, ist eine nach Wert sortierte Karte.

Könnten Sie das nicht mit einer SortedMap machen?
Nein, weil die Karte nach ihren Schlüsseln sortiert wird.

Methode 1:

Der folgende Java-Code:

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
 
public class Main {
  public static void main(String[] args) {
 
    Set set = new TreeSet();
    set.add(new Pair("me", "1000"));
 
    set.add(new Pair("and", "4000"));
    set.add(new Pair("you", "3000"));
 
    set.add(new Pair("food", "10000"));
    set.add(new Pair("hungry", "5000"));
 
    set.add(new Pair("later", "6000"));
    set.add(new Pair("myself", "1000"));
 
    for (Iterator i = set.iterator(); i.hasNext();)
 
      System.out.println(i.next());
  }
}
 
class Pair implements Comparable {
  private final String name;
  private final int number;
 
  public Pair(String name, int number) {
    this.name = name;
    this.number = number;
  }
 
  public Pair(String name, String number) throws NumberFormatException {
    this.name = name;
    this.number = Integer.parseInt(number);
 
  }
 
  public int compareTo(Object o) {
    if (o instanceof Pair) {
      int cmp = Double.compare(number, ((Pair) o).number);
      if (cmp != 0) {
        return cmp;
      }
      return name.compareTo(((Pair) o).name);
    }
 
    throw new ClassCastException("Cannot compare Pair with "
        + o.getClass().getName());
 
  }
 
  public String toString() {
    return name + ' ' + number;
  }
}

Ähnlicher C++-Code:

typedef pair<string, int> PAIR;
 
int cmp(const PAIR& x, const PAIR& y)
{
  return x.second > y.second;
}
 
map<string,int> m;
vector<PAIR> vec;
for (map<wstring,int>::iterator curr = m.begin(); curr != m.end(); ++curr)
{
  vec.push_back(make_pair(curr->first, curr->second));
}
sort(vec.begin(), vec.end(), cmp);

Die wesentliche Bedeutung der obigen Methode besteht darin, die Schlüssel-Wert-Paare (Map.Entry) in der Map-Struktur in eine benutzerdefinierte Klasse (Struktur) zu kapseln oder die Map.Entry-Klasse direkt zu verwenden. Die benutzerdefinierte Klasse weiß, wie sie sortiert werden soll, dh nach Wert sortiert. Insbesondere implementiert sie die Comparable-Schnittstelle oder erstellt ein Comparator-Objekt für sich selbst und verwendet dann stattdessen eine geordnete Menge (SortedSet, TreeSet ist eine Implementierung von SortedSet). eine Map-Struktur, damit der Zweck der Sortierung nach Wert in der Map erreicht wird. Das heißt, anstatt Map zu verwenden, behandeln Sie Map.Entry als Objekt, sodass das Problem darin besteht, eine geordnete Sammlung des Objekts zu implementieren oder die Sammlung des Objekts zu sortieren. Sie können entweder ein SortedSet verwenden, damit es nach Abschluss der Einfügung auf natürliche Weise sortiert wird, oder Sie können eine Liste oder ein Array verwenden und es dann sortieren (Collections.sort() oder Arrays.sort()).

Kapseln Sie die Informationen in einer eigenen Klasse. Implementieren Sie entweder
Comparable und schreiben Sie Regeln für die natürliche Reihenfolge oder schreiben Sie einen
Komparator basierend auf Ihren Kriterien.
collection, oder verwenden Sie die Methode Collections.sort().

Methode 2:

Sie können auch den folgenden Code verwenden, um nach Wert zu sortieren:

public static Map sortByValue(Map map) {
    List list = new LinkedList(map.entrySet());
    Collections.sort(list, new Comparator() {
 
      public int compare(Object o1, Object o2) {
        return ((Comparable) ((Map.Entry) (o1)).getValue())
            .compareTo(((Map.Entry) (o2)).getValue());
 
      }
    });
    Map result = new LinkedHashMap();
 
    for (Iterator it = list.iterator(); it.hasNext();) {
      Map.Entry entry = (Map.Entry) it.next();
      result.put(entry.getKey(), entry.getValue());
    }
    return result;
  }
 
  public static Map sortByValue(Map map, final boolean reverse) {
    List list = new LinkedList(map.entrySet());
    Collections.sort(list, new Comparator() {
 
      public int compare(Object o1, Object o2) {
        if (reverse) {
          return -((Comparable) ((Map.Entry) (o1)).getValue())
              .compareTo(((Map.Entry) (o2)).getValue());
        }
        return ((Comparable) ((Map.Entry) (o1)).getValue())
            .compareTo(((Map.Entry) (o2)).getValue());
      }
    });
 
    Map result = new LinkedHashMap();
    for (Iterator it = list.iterator(); it.hasNext();) {
      Map.Entry entry = (Map.Entry) it.next();
      result.put(entry.getKey(), entry.getValue());
    }
    return result;
  }
 
 
 
 
        Map map = new HashMap();
    map.put("a", 4);
    map.put("b", 1);
    map.put("c", 3);
    map.put("d", 2);
    Map sorted = sortByValue(map);
    System.out.println(sorted);
// output : {b=1, d=2, c=3, a=4}
 
或者还可以这样：
Map map = new HashMap();
    map.put("a", 4);
    map.put("b", 1);
    map.put("c", 3);
    map.put("d", 2);
 
    Set<Map.Entry<String, Integer>> treeSet = new TreeSet<Map.Entry<String, Integer>>(
        new Comparator<Map.Entry<String, Integer>>() {
          public int compare(Map.Entry<String, Integer> o1,
              Map.Entry<String, Integer> o2) {
            Integer d1 = o1.getValue();
            Integer d2 = o2.getValue();
            int r = d2.compareTo(d1);
 
            if (r != 0)
              return r;
            else
              return o2.getKey().compareTo(o1.getKey());
          }
 
        });
    treeSet.addAll(map.entrySet());
    System.out.println(treeSet);
    // output : [a=4, c=3, d=2, b=1]

Darüber hinaus ist in Groovy das Sortieren der Karte nach Wert implementiert. Natürlich ist das Wesentliche das Gleiche, aber es ist sehr einfach:

Verwenden Sie die Sortiermethode der Karte in groovy (erfordert groovy 1.6),

def result = map.sort(){ a, b ->
      b.value.compareTo(a.value)
    }

Zum Beispiel:

["a":3,"b":1,"c ":4,"d": 2].sort{ a,b -> a.value - b.value }

Das Ergebnis ist: [b:1, d:2, a :3, c:4]

In Python ist es ähnlich:

h = {"a":2,"b":1,"c":3}
i = h.items() // i = [('a', 2), ('c', 3), ('b', 1)]
i.sort(lambda (k1,v1),(k2,v2): cmp(v2,v1) ) // i = [('c', 3), ('a', 2), ('b', 1)]

Der obige Artikel geht kurz auf die Kartensortierung nach Wert in Java ein Ich teile den gesamten Inhalt hier und hoffe, dass er jedem eine Referenz geben kann, und ich hoffe auch, dass jeder die chinesische PHP-Website unterstützt.

Weitere Artikel zur Kartensortierung nach Wert in Java finden Sie auf der chinesischen PHP-Website!