我建议使用Arrays.sort，而不是像某些人那样使用Collections.ort。实际上Collections.ort的作用是这样的：

public static <T extends Comparable<? super T>> void sort(List<T> list) {
    Object[] a = list.toArray();
    Arrays.sort(a);
    ListIterator<T> i = list.listIterator();
    for (int j=0; j<a.length; j++) {
        i.next();
        i.set((T)a[j]);
    }
}

它只调用列表上的array，然后使用Arrays.sort。这样，所有映射条目将被复制三次：一次从映射复制到临时列表（无论是LinkedList还是ArrayList），然后复制到临时数组，最后复制到新映射。

我的解决方案省略了这一步，因为它不会创建不必要的LinkedList。以下是代码，通用友好，性能最佳：

public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) 
{
    @SuppressWarnings("unchecked")
    Map.Entry<K,V>[] array = map.entrySet().toArray(new Map.Entry[map.size()]);

    Arrays.sort(array, new Comparator<Map.Entry<K, V>>() 
    {
        public int compare(Map.Entry<K, V> e1, Map.Entry<K, V> e2) 
        {
            return e1.getValue().compareTo(e2.getValue());
        }
    });

    Map<K, V> result = new LinkedHashMap<K, V>();
    for (Map.Entry<K, V> entry : array)
        result.put(entry.getKey(), entry.getValue());

    return result;
}

主要问题。如果您使用第一个答案（Google将您带到这里），请更改比较器以添加等号子句，否则无法按键从sorted_map中获取值：

public int compare(String a, String b) {
        if (base.get(a) > base.get(b)) {
            return 1;
        } else if (base.get(a) < base.get(b)){
            return -1;
        } 

        return 0;
        // returning 0 would merge keys
    }

我合并了user157196和Carter Page的解决方案：

class MapUtil {

    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue( Map<K, V> map ){
        ValueComparator<K,V> bvc =  new ValueComparator<K,V>(map);
        TreeMap<K,V> sorted_map = new TreeMap<K,V>(bvc);
        sorted_map.putAll(map);
        return sorted_map;
    }

}

class ValueComparator<K, V extends Comparable<? super V>> implements Comparator<K> {

    Map<K, V> base;
    public ValueComparator(Map<K, V> base) {
        this.base = base;
    }

    public int compare(K a, K b) {
        int result = (base.get(a).compareTo(base.get(b)));
        if (result == 0) result=1;
        // returning 0 would merge keys
        return result;
    }
}

我可以给你举个例子，但这肯定是你需要的。

map = {10 = 3, 11 = 1,12 = 2} 

假设你想要前2个最常用的键，即（10，12）因此，最简单的方法是使用PriorityQueue根据映射的值进行排序。

PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> (map.get(a) - map.get(b));
for(int key: map.keySets()) {
   pq.add(key);
   if(pq.size() > 2) {
      pq.poll();
   }
}
// Now pq has the top 2 most frequent key based on value. It sorts the value. 

根据上下文，使用java.util.LinkedHashMap<T>来记住项目在映射中的放置顺序。否则，如果您需要根据值的自然排序对值进行排序，我建议您维护一个单独的List，该List可以通过Collections.sort（）进行排序。

这太复杂了。地图不应该按价值排序。最简单的方法是创建自己的类，以满足您的需求。

在下面的示例中，您应该在*所在的位置添加TreeMap比较器。但通过javaAPI，它只提供比较器键，而不提供值。此处所述的所有示例均基于2个地图。一个哈希和一个新树。这很奇怪。

示例：

Map<Driver driver, Float time> map = new TreeMap<Driver driver, Float time>(*);

因此，通过以下方式将地图更改为集合：

ResultComparator rc = new ResultComparator();
Set<Results> set = new TreeSet<Results>(rc);

您将创建类Results，

public class Results {
    private Driver driver;
    private Float time;

    public Results(Driver driver, Float time) {
        this.driver = driver;
        this.time = time;
    }

    public Float getTime() {
        return time;
    }

    public void setTime(Float time) {
        this.time = time;
    }

    public Driver getDriver() {
        return driver;
    }

    public void setDriver (Driver driver) {
        this.driver = driver;
    }
}

以及Comparator类：

public class ResultsComparator implements Comparator<Results> {
    public int compare(Results t, Results t1) {
        if (t.getTime() < t1.getTime()) {
            return 1;
        } else if (t.getTime() == t1.getTime()) {
            return 0;
        } else {
            return -1;
        }
    }
}

这样，您可以轻松添加更多依赖项。

最后一点，我将添加简单迭代器：

Iterator it = set.iterator();
while (it.hasNext()) {
    Results r = (Results)it.next();
    System.out.println( r.getDriver().toString
        //or whatever that is related to Driver class -getName() getSurname()
        + " "
        + r.getTime()
        );
}