Map是键值对的集合,又叫作字典或关联数组等,是最常见的数据结构之一。在java如何让一个map按value排序呢? 看似简单,但却不容易!
比如,Map中key是String类型,表示一个单词,而value是int型,表示该单词出现的次数,现在我们想要按照单词出现的次数来排序:
1
2
3
4
5
6
7
|
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 );
|
按值排序的结果应该是:
1
2
3
4
5
6
7
|
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代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
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++代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
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:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
|
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]
|
另外,Groovy 中实现 sort map by value,当然本质是一样的,但却很简洁 :
用 groovy 中 map 的 sort 方法(需要 groovy 1.6),
1
2
3
|
def result = map.sort(){ a, b ->
b.value.compareTo(a.value)
}
|
如:
["a":3,"b":1,"c":4,"d":2].sort{ a,b -> a.value - b.value }
结果为: [b:1, d:2, a:3, c:4]
Python中也类似:
1
2
3
|
h = { "a" : 2 , "b" : 1 , "c" : 3 }
i = h.items() / / i = [( 'a' , 2 ), ( 'c' , 3 ), ( 'b' , 1 )]
i.sort( lambda (k1,v1),(k2,v2): cmp (v2,v1) ) / / i = [( 'c' , 3 ), ( 'a' , 2 ), ( 'b' , 1 )]
|
以上这篇浅谈Java之Map 按值排序 (Map sort by value)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持服务器之家。