Java の Map の値による並べ替え (Map sort by value) についての簡単な説明

マップはキーと値のペアのコレクションであり、辞書や連想配列などとも呼ばれます。最も一般的なデータ構造の 1 つです。 Javaでマップを値で並べ替える方法は? 簡単そうに見えますが、簡単ではありません！

たとえば、マップ内のキーは単語を表す String 型で、値は単語が出現する回数を表す int 型です。今度は単語の出現回数で並べ替えます。

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

値でソートした結果は次のようになります:

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

まず第一に、SortedMap はキーでソートされた Map であり、値でソートされた Map ではないため、SortedMap 構造は使用できません。値でソートされたマップが必要です。

SortedMap を使用してこれを行うことはできませんか?
いいえ、マップはキーによって並べ替えられているためです。

方法 1:

次の Java コード:

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

同様の C++ コード:

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

上記のメソッドの本質的な意味は、Map 構造内のキーと値のペア (Map.Entry) をカスタム クラス (構造) にカプセル化するか、Map.Entry クラスを直接使用することです。カスタム クラスは、ソート方法、つまり値によるソートを知っています。具体的には、Comparable インターフェイスを実装するか、独自の Comparator オブジェクトを構築し、代わりに順序付きセット (SortedSet、TreeSet は SortedSet の実装) を使用します。 Map 構造。これにより、Map の値による並べ替えの目的が達成されます。つまり、Map を使用する代わりに、Map.Entry をオブジェクトとして扱うため、問題はオブジェクトの順序付きコレクションを実装するか、オブジェクトのコレクションをソートするかになります。 SortedSet を使用して挿入完了後に自然に並べ替えることも、List または配列を使用して並べ替えることもできます (Collections.sort() または Arrays.sort())。

情報を独自のクラスにカプセル化します。
Comparable を実装して自然な順序付けのルールを記述するか、基準に基づいて
Comparator を作成して情報をsorted
コレクションに保存するか、Collections.sort() メソッドを使用します。 .

方法 2:

次のコードを使用して値で並べ替えることもできます:

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]

さらに、値による並べ替えマップは、もちろん本質は同じですが、Groovy で実装されています。非常に簡単:

groovy でマップの sort メソッドを使用します (groovy 1.6 が必要)、

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

など:

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

結果は次のようになります: [b:1, d:2, a:3, c:4]

Python でも同様です:

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)]

上記の記事は、Java の値によるマップの並べ替え (値によるマップの並べ替え) について簡単に説明したものであり、エディターが共有するすべての内容です。参考になれば幸いです。サポートしていただければ幸いです。 PHP中国語ウェブサイト。

Java の Map sort by value (Map sort by value) に関するその他の記事については、PHP 中国語 Web サイトに注目してください。