java comparator_Java：按值对map进行排序

在Java中，我们可以使用TreeMap该类通过其键对地图进行排序。该类非常易于使用。但是，有时我们需要按其值对map进行排序。如何通过其值对映射进行排序是Java程序员最常问的问题。在本文中，我将开发编写这种方法的最佳方法。

1.天真的方法

以下是对对的映射进行排序的解决方案。这通常用于计数单词的频率。

import java.util.Comparator;import java.util.HashMap;import java.util.TreeMap;

public class SortMapByValue {

public static void main(String[] args) {

HashMap map = new HashMap();

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 sortedMap = sortMapByValue(map);

System.out.println(sortedMap);

}

public static TreeMap sortMapByValue(HashMap map){

Comparator comparator = new ValueComparator(map);

//TreeMap is a map sorted by its keys.

//The comparator is used to sort the TreeMap by keys.

TreeMap result = new TreeMap(comparator);

result.putAll(map);

return result;

}}

这是比较器类的实现。

// a comparator that compares Stringsclass ValueComparator implements Comparator{

HashMap map = new HashMap();

public ValueComparator(HashMap 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 map = new HashMap();

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

// Map

HashMap map = new HashMap();

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 comparator = new ValueComparator(map);

TreeMap result = new TreeMap(comparator);

result.putAll(map);

System.out.println(result);

// Map

HashMap map2 = new HashMap();

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 comparator2 = new ValueComparator(map2);

TreeMap result2 = new TreeMap(comparator2);

result2.putAll(map2);

System.out.println(result2);

}

}

// a comparator using generic typeclass ValueComparatorextends Comparable> implements Comparator{

HashMap map = new HashMap();

public ValueComparator(HashMap 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 extends Comparable super V>> Map sortByValue(Map map) {

List> list = new LinkedList<>(map.entrySet());

Collections.sort(list, new Comparator>() {

@Override

public int compare(Map.Entry e1, Map.Entry e2) {

return (e1.getValue()).compareTo(e2.getValue());

}

});

Map result = new LinkedHashMap<>();

for (Map.Entry entry : list) {

result.put(entry.getKey(), entry.getValue());

}

return result;}

5.简单

当需要简单的解决方案时，可以在一行中完成排序。

LinkedList> list = new LinkedList<>(counter.entrySet());

Comparator> comparator = Comparator.comparing(Map.Entry::getValue);Collections.sort(list, comparator.reversed());

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