关于HashMap排序的一点浅见

我们在对hashmap进行排序的时候存在一定的误解，首先在这更正下~

我在遇到这个问题的时候也上网查了相关的资料，发现大家在进行hashmap进行排序的时候存在一定的了解误区。



有很多人认为把hashmap遍历一下，然后对其中的key和value进行排序，然后打印出来~



大家想一想，这样的hashmap排序根本就不是对hashmap进行排序~最多也只能称为hashmap遍历，hashmap的遍历问题很简单，网上也有很多相关的资料，下面我给出一个例程：

1. public static void itHashMap(Map<Object, Object> m) {
2. Set set = m.entrySet();
3. Iterator it = set.iterator();
4. while(it.hasNext()) {
5. Map.Entry<Object, Object> me = (Map.Entry<Object, Object>)it.next();
6. System.out.println("key:" + me.getKey() + "----value" + me.getValue());
7. }
8. }



这个方法可以将hashmap遍历，并打印出相应的key和value！



其实，单纯的hashmap是无法实现排序的，我这里的排序是指，我们将键值对按照一定的顺序put进hashmap里，然后在进行取键值对的操作的时候，在按照put进去的顺序把键值对取出来。



下面我来浅显的解释下为什么不能排序.

1. HashMap<String, Date> hm = new HashMap<String, Date>();
2. hm.put("1", new Date(8,10,1));
3. hm.put("3", new Date(8,10,3));
4. hm.put("2", new Date(8,10,2));
5. hm.put("5", new Date(8,10,5));
6. hm.put("9", new Date(8,10,9));
7. hm.put("8", new Date(8,10,8));
8. hm.put("6", new Date(8,10,6));
9. hm.put("7", new Date(8,10,7));

我在hashmap里按照以上的顺序放入9个键值对，然后我遍历hashmap打印出上面hm里的键值对：

key:3----value:Tue Nov 03 00:00:00 CST 1908
key:5----value:Thu Nov 05 00:00:00 CST 1908
key:7----value:Sat Nov 07 00:00:00 CST 1908
key:2----value:Mon Nov 02 00:00:00 CST 1908
key:9----value:Mon Nov 09 00:00:00 CST 1908
key:8----value:Sun Nov 08 00:00:00 CST 1908
key:6----value:Fri Nov 06 00:00:00 CST 1908
key:1----value:Sun Nov 01 00:00:00 CST 1908

我们从上面的结果可以看出，取出来的顺序并我们想要的顺序！

hashmap在put的时候是根据key的hashcode进行hash然后放入对应的地方！通过Debug可以看到HashMap的存放位置,网上有很多人说是随即存放，随即取，其实不然，放的时候是根据hashcode经过 hash算法进行存放的，而我们取的时候也是想过key来取value。所以你取出来拍完序，在放入HashMap的时候哦，它又把顺序打乱了~~（这里说的打乱也不是完全没有规律可循的，主要是你根据你的key来放的）！



所以我们要实现HashMap排序的时候就要借用别的集合来完成这个功能！



基本的思路是这样的，首先遍历HashMap取出相应的键值对，然后根据key或者是value进行排序，然后放入一个有序的集合当中，这样就实现了排序！



java在JDK1.4以后提供了LinkedHashMap来帮我们实现了有序的HashMap！



LinkedHashMap取键值对的时，是按照你放入的顺序来取的！



具体的排序算法有很多种~也可以自己写个冒泡排序取排列~~



再排完序以后，我们要找到key对应的vluae或是value对应的key！找key对应的vluea的时候很简单，网上有很多资料，我这里就不说了~~关键说说找value对应的key的时候，有的朋友就不知道该怎么做了~~



下面我提供两种思路



一种是我们可以把value放入一个数组，key也放入一个数组，这样在排序的时候按照value排序的时候，我们把key的位置也交换一次，这样就保证了键值对的完整性，见例程：

1. private static void sortHashMap(HashMap<String, Date> hm) {
2.
3. List<Date> dateListSorted = new ArrayList<Date> ();
4.
5. int size = hm.size();
6. Date[] dates = new Date[size];
7. Set set = hm.keySet();
8. Iterator iteratorSet = set.iterator();
9. int k = 0;
10. while(iteratorSet.hasNext()) {
11. String keyStr = (String)iteratorSet.next();
12. System.out.println("key from set----" + keyStr);
13. if(keyStr!=null && !(keyStr.length()<1)) {
14. dates[k] = hm.get(keyStr);
15. k++;
16. }
17. System.out.println("value from hashmap----" + hm.get(keyStr));
18. }
19. iteratorList.next());
20. int sizeList = dates.length;
21. Object[] keyObj = set.toArray();
22. for(int i=0;i<sizeList;i++) {//冒泡排序
23. for(int j=i;j<sizeList;j++) {
24. if(dates[j].after(dates[i])) {
25. Date temp = dates[i];//交换value
26. dates[i] = dates[j];
27. dates[j] = temp;
28. Object objectTemp = keyObj[i];//交换key
29. keyObj[i] = keyObj[j];
30. keyObj[j] = objectTemp;
31. }
32.
33. }
34. }
35. for(int i=0;i<keyObj.length;i++) {
36. System.out.println("key from array sorted----" + keyObj[i]);
37. }
38. for(int i=0;i<dates.length;i++) {
39. System.out.println("value from list sorted----" + dates[i]);
40. }
41. LinkedHashMap lhm = new LinkedHashMap();
42. for(int i=0;i<keyObj.length;i++) {//把经过排序的键值对放入Linked中
43. lhm.put(keyObj[i], dates[i]);
44. }
45. /*
46. *遍历Linkedhashmap打印出结果
47. */
48. Set set1 = lhm.entrySet();
49. Iterator it = set1.iterator();
50. while(it.hasNext()) {
51. Map.Entry me = (Map.Entry)it.next();
52. System.out.println("key:" + me.getKey() + "----value" + me.getValue());
53. }
54. }

这种方法比较直观，可是效率比较低，而且对内存也很浪费，你想想，在这个过程中我们new了两个长度是hm.size（）长度的数组，用于存放key和value，排序也是我们自己写的冒泡排序法~~



下面我介绍第二种方法：



第二种方法的思路是这样的，我们用hm.value()放回hm的vuale集合，再把它转换成一个数组，然后调用jdk给我们提供的Arrays.sort（）方法去帮我们排序，这样效率会比自己写的冒泡排序法效率高的多！



在调用sort方法的时候我们需要写一个比较器，比较器的代码如下：





1. package com.mgoann.test1;
2.
3. import java.util.Comparator;
4. import java.util.Date;
5.
6. public final class DateComp implements Comparator {
7.
8. public int compare(Object o1, Object o2) {
9. Date date1 = (Date)o1;
10. Date date2 = (Date)o2;
11. return date2.compareTo(date1);
12. }
13.
14. }
15.

剩下的就是更具value去找相应的key的问题了~~这里我用了一个for循环和Iterator去查找hm里的key，找到以后我们就放到LinkedHashMap里~，详见例程：

1. package com.mgoann.test1;
2.
3. import java.util.Arrays;
4. import java.util.Collection;
5. import java.util.Comparator;
6. import java.util.Date;
7. import java.util.HashMap;
8. import java.util.Iterator;
9. import java.util.LinkedHashMap;
10. import java.util.Map;
11. import java.util.Set;
12.
13. public class Sort {
14.
15. /**
16. * @param args
17. */
18. public static void main(String[] args) {
19. HashMap<String, Date> hm = new HashMap<String, Date>();
20. LinkedHashMap<String, Date> linkedHM = new LinkedHashMap<String, Date>();
21. hm.put("1", new Date(8,10,1));
22. hm.put("3", new Date(8,10,3));
23. hm.put("2", new Date(8,10,2));
24. hm.put("5", new Date(8,10,5));
25. hm.put("9", new Date(8,10,9));
26. hm.put("8", new Date(8,10,8));
27. hm.put("6", new Date(8,10,6));
28. hm.put("7", new Date(8,10,7));
29. itHashMap(hm);
30. linkedHM = sortHashMap(hm);
31. itHashMap(linkedHM);
32. }
33.
34. private static LinkedHashMap sortHashMap(HashMap<String, Date> hm) {
35.
36. LinkedHashMap<String, Date> linkedHM = new LinkedHashMap<String, Date>();
37. final Comparator DATE_COMP = new DateComp();
38.
39. int index = 0;
40.
41. Collection<Date> DateColl = hm.values();
42. Object[] dates = DateColl.toArray();
43. Arrays.sort(dates, DATE_COMP);
44. System.out.println("dates after sorted");
45. printElements(dates);
46. Set set = hm.entrySet();
47. for(int j=0;j<dates.length;j++) {
48. Iterator it = set.iterator();
49. while(it.hasNext()) {
50. Map.Entry<String, Date> me = (Map.Entry<String, Date>)it.next();
51. if(dates[j].equals(me.getValue())) {
52. linkedHM.put(me.getKey(), me.getValue());
53. }
54. }
55. }
56. return linkedHM;
57. }
58.
59. public static void printElements(Collection c) {
60. Iterator it = c.iterator();
61. while(it.hasNext()) {
62. System.out.println(it.next());
63. }
64. }
65.
66. public static void printElements(Object[] dates) {
67. for(int i=0;i<dates.length;i++) {
68. System.out.println(dates[i]);
69. }
70. }
71.
72. public static void itHashMap(Map<String, Date> m) {
73. Set set = m.entrySet();
74. Iterator it = set.iterator();
75. while(it.hasNext()) {
76. Map.Entry<String, Date> me = (Map.Entry<String, Date>)it.next();
77. System.out.println("key:" + me.getKey() + "----value:" + me.getValue());
78. }
79. }
80. }

这样我们就实现了HashMap的排序问题！



程序运行结果如下：

key:3----value:Tue Nov 03 00:00:00 CST 1908
key:5----value:Thu Nov 05 00:00:00 CST 1908
key:7----value:Sat Nov 07 00:00:00 CST 1908
key:2----value:Mon Nov 02 00:00:00 CST 1908
key:9----value:Mon Nov 09 00:00:00 CST 1908
key:8----value:Sun Nov 08 00:00:00 CST 1908
key:6----value:Fri Nov 06 00:00:00 CST 1908
key:1----value:Sun Nov 01 00:00:00 CST 1908
dates after sorted
Mon Nov 09 00:00:00 CST 1908
Sun Nov 08 00:00:00 CST 1908
Sat Nov 07 00:00:00 CST 1908
Fri Nov 06 00:00:00 CST 1908
Thu Nov 05 00:00:00 CST 1908
Tue Nov 03 00:00:00 CST 1908
Mon Nov 02 00:00:00 CST 1908
Sun Nov 01 00:00:00 CST 1908
key:9----value:Mon Nov 09 00:00:00 CST 1908
key:8----value:Sun Nov 08 00:00:00 CST 1908
key:7----value:Sat Nov 07 00:00:00 CST 1908
key:6----value:Fri Nov 06 00:00:00 CST 1908
key:5----value:Thu Nov 05 00:00:00 CST 1908
key:3----value:Tue Nov 03 00:00:00 CST 1908
key:2----value:Mon Nov 02 00:00:00 CST 1908
key:1----value:Sun Nov 01 00:00:00 CST 1908