Java：按值对map进行排序

在Java中，我们可以使用TreeMap该类通过其键对地图进行排序。该类非常易于使用。但是，有时我们需要按其值对map进行排序。如何通过其值对映射进行排序是Java程序员最常问的问题。在本文中，我将开发编写这种方法的最佳方法。
1.天真的方法
以下是对<String，Integer>对的映射进行排序的解决方案。这通常用于计数单词的频率。
import java.util.Comparator;import java.util.HashMap;import java.util.TreeMap;
public class SortMapByValue {

public static void main(String[] args) {
	HashMap<String, Integer> map = new HashMap<String, Integer>();
	map.put("a", 10);
	map.put("b", 30);
	map.put("c", 50);
	map.put("d", 40);
	map.put("e", 20);
	System.out.println(map);

	TreeMap<String, Integer> sortedMap = sortMapByValue(map);  
	System.out.println(sortedMap);
}

public static TreeMap<String, Integer> sortMapByValue(HashMap<String, Integer> map){
	Comparator<String> comparator = new ValueComparator(map);
	//TreeMap is a map sorted by its keys. 
	//The comparator is used to sort the TreeMap by keys. 
	TreeMap<String, Integer> result = new TreeMap<String, Integer>(comparator);
	result.putAll(map);
	return result;
}}

这是比较器类的实现。
// a comparator that compares Stringsclass ValueComparator implements Comparator{

HashMap<String, Integer> map = new HashMap<String, Integer>();

public ValueComparator(HashMap<String, Integer> map){
	this.map.putAll(map);
}

@Override
public int compare(String s1, String s2) {
	if(map.get(s1) >= map.get(s2)){
		return -1;
	}else{
		return 1;
	}	
}}

在此解决方案中，我们使用TreeMap对地图进行排序。创建TreeMap时，我们给它一个比较器。比较器接受字符串，并比较映射中给定字符串键的关联值。
该方法效果很好，但仅适用于对String和Integer对进行排序。如果我们想使用其他类型的键和值对地图进行排序，则需要对其进行重写。因此，更通用的解决方案是首选。
2.更一般的解决方案
我们可以忽略泛型，并使方法适用于任何类型，如下所示。
import java.util.Comparator;import java.util.HashMap;import java.util.Map;import java.util.TreeMap;
public class Solution {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put(“a”, 10);
map.put(“b”, 30);
map.put(“c”, 50);
map.put(“d”, 40);
map.put(“e”, 20);
System.out.println(map);

	Map sortedMap = sortByValue(map);
	System.out.println(sortedMap);
}

public static Map sortByValue(Map unsortedMap) {
	Map sortedMap = new TreeMap(new ValueComparator(unsortedMap));
	sortedMap.putAll(unsortedMap);
	return sortedMap;
}

}
class ValueComparator implements Comparator {
Map map;

public ValueComparator(Map map) {
	this.map = map;
}

public int compare(Object keyA, Object keyB) {
	Comparable valueA = (Comparable) map.get(keyA);
	Comparable valueB = (Comparable) map.get(keyB);
	return valueB.compareTo(valueA);
}}

该解决方案不是类型安全的，我们需要一个类型安全的通用解决方案。
3.使用泛型类型
public class SortMapByValue {

public static void main(String[] args) {
	// <String, Integer> Map
	HashMap<String, Integer> map = new HashMap<String, Integer>();
	map.put("a", 10);
	map.put("b", 30);
	map.put("c", 50);
	map.put("d", 40);
	map.put("e", 20);
	System.out.println(map);


	Comparator<String> comparator = new ValueComparator<String, Integer>(map);
	TreeMap<String, Integer> result = new TreeMap<String, Integer>(comparator);
	result.putAll(map);

	System.out.println(result);

	// <Integer, Integer> Map

	HashMap<Integer, Integer> map2 = new HashMap<Integer, Integer>();
	map2.put(1, 10);
	map2.put(2, 30);
	map2.put(3, 50);
	map2.put(4, 40);
	map2.put(5, 20);
	System.out.println(map2);

	Comparator<Integer> comparator2 = new ValueComparator<Integer, Integer>(map2);
	TreeMap<Integer, Integer> result2 = new TreeMap<Integer, Integer>(comparator2);
	result2.putAll(map2);

	System.out.println(result2);

}

}
// a comparator using generic typeclass ValueComparator<K, V extends Comparable> implements Comparator{

HashMap<K, V> map = new HashMap<K, V>();

public ValueComparator(HashMap<K, V> map){
	this.map.putAll(map);
}

@Override
public int compare(K s1, K s2) {
	return -map.get(s1).compareTo(map.get(s2));//descending order	
}}

4.使用泛型类型的另一种方法
public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
List<Map.Entry<K, V>> list = new LinkedList<>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<K, V>>() {
@Override
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<>();
for (Map.Entry<K, V> entry : list) {
	result.put(entry.getKey(), entry.getValue());
}

return result;}

5.简单
当需要简单的解决方案时，可以在一行中完成排序。
LinkedList<Map.Entry<String, Integer>> list = new LinkedList<>(counter.entrySet());
Comparator<Map.Entry<String, Integer>> comparator = Comparator.comparing(Map.Entry::getValue);Collections.sort(list, comparator.reversed());

最后，开发这么多年我也总结了一套学习Java的资料与面试题，如果你在技术上面想提升自己的话，可以关注我，私信发送领取资料或者在评论区留下自己的联系方式，有时间记得帮我点下转发让跟多的人看到哦。