Map按值進行排序

Map是鍵值對的集合，又叫作字典或關聯數組等，是最常見的數據結構之一。在java如何讓一個map按value排序呢？ 看似簡單，但卻不容易！

比如，Map中key是String類型，表示一個單詞，而value是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結構，因爲SortedMap是按鍵排序的Map，而不是按值排序的Map，我們要的是按值排序的Map。

Couldn't you do this with a SortedMap? 
No, because the map are being sorted by its keys.

方法一：

如下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對象，然後不用Map結構而採用有序集合（SortedSet, TreeSet是SortedSet的一種實現)，這樣就實現了Map中sort by value要達到的目的。就是說，不用Map，而是把Map.Entry當作一個對象，這樣問題變爲實現一個該對象的有序集合或對該對象的集合做排序。既可以用SortedSet，這樣插入完成後自然就是有序的了，又或者用一個List或數組，然後再對其做排序（Collections.sort() or Arrays.sort()）。

Encapsulate the information in its own class. Either implement
Comparable and write rules for the natural ordering or write a
Comparator based on your criteria. Store the information in a sorted
collection, or use the Collections.sort() method.

方法二：

You can also use the following code to sort by value:

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]