鲁达 在Java中，我们可以使用TreeMap该类通过其键对地图进行排序。该类非常易于使用。但是，有时我们需要按其值对map进行排序。如何通过其值对映射进行排序是Java程序员最常问的问题。在本文中，我将开发编写这种方法的最佳方法。
1.天真的方法
以下是对<String，Integer>对的映射进行排序的解决方案。这通常用于计数单词的频率。
import java.u;import java.u;import java.u;
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);
Sy(map);
TreeMap<String, Integer> sortedMap = sortMapByValue(map);
Sy(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);
re(map);
return result;
}}
这是比较器类的实现。
// a comparator that compares Stringsclass ValueComparator implements Comparator<String>{
HashMap<String, Integer> map = new HashMap<String, Integer>();
public ValueComparator(HashMap<String, Integer> map){
(map);
}
@Override
public int compare(String s1, String s2) {
i(s1) >= map.get(s2)){
return -1;
}else{
return 1;
}
}}
在此解决方案中，我们使用TreeMap对地图进行排序。创建TreeMap时，我们给它一个比较器。比较器接受字符串，并比较映射中给定字符串键的关联值。
该方法效果很好，但仅适用于对String和Integer对进行排序。如果我们想使用其他类型的键和值对地图进行排序，则需要对其进行重写。因此，更通用的解决方案是首选。
2.更一般的解决方案
我们可以忽略泛型，并使方法适用于任何类型，如下所示。
import java.u;import java.u;import java.u;import java.u;
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);
Sy(map);
Map sortedMap = sortByValue(map);
Sy(sortedMap);
}
public static Map sortByValue(Map unsortedMap) {
Map sortedMap = new TreeMap(new ValueComparator(unsortedMap));
(unsortedMap);
return sortedMap;
}
}
class ValueComparator implements Comparator {
Map map;
public ValueComparator(Map 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);
Sy(map);
Comparator<String> comparator = new ValueComparator<String, Integer>(map);
TreeMap<String, Integer> result = new TreeMap<String, Integer>(comparator);
re(map);
Sy(result);
// <Integer, Integer> Map
HashMap<Integer, Integer> map2 = new HashMap<Integer, Integer>();
ma(1, 10);
ma(2, 30);
ma(3, 50);
ma(4, 40);
ma(5, 20);
Sy(map2);
Comparator<Integer> comparator2 = new ValueComparator<Integer, Integer>(map2);
TreeMap<Integer, Integer> result2 = new TreeMap<Integer, Integer>(comparator2);
re(map2);
Sy(result2);
}
}
// a comparator using generic typeclass ValueComparator<K, V extends Comparable<V>> implements Comparator<K>{
HashMap<K, V> map = new HashMap<K, V>();
public ValueComparator(HashMap<K, V> map){
(map);
}
@Override
public int compare(K s1, K s2) {
return -map.get(s1).compareTo(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<>());
Collec(list, new Comparator<Map.Entry<K, V>>() {
@Override
public int compare;K, V> e1, Map.Entry<K, V> e2) {
return ()).compareTo());
}
});
Map<K, V> result = new LinkedHashMap<>();
for ;K, V> entry : list) {
re(), en());
}
return result;}
5.简单
当需要简单的解决方案时，可以在一行中完成排序。
LinkedList<Map.Entry<String, Integer>> list = new LinkedList<>());
Comparator<Map.Entry<String, Integer>> comparator = Com(Map.Entry::getValue);Collec(list, com());
最后，开发这么多年我也总结了一套学习Java的资料与面试题，如果你在技术上面想提升自己的话，可以关注我，私信发送领取资料或者在评论区留下自己的联系方式，有时间记得帮我点下转发让跟多的人看到哦。