如何对HashMap按键值排序

Java中HashMap是一种用于存储“键”和“值”信息对的数据结构。不同于Array、ArrayList和LinkedLists,它不会维持插入元素的顺序。

Map<String,Integer> rst = new LinkedHashMap<String, Integer>();直接换成这个就可以记住插入顺序

HashMap 会根据 string 排序从小到大,Integer放前面数字相同会只记录后面的前面的就丢失了。

1. HashMap存储每对键和值作为一个Entry<K,V>对象。例如,给出一个HashMap,

[html] view plain copy
 print?
  1. Map<String,Integer> aMap = new HashMap<String,Integer>();  
键的每次插入,都会有值对应到散列映射上,生成一个Entry <K,V>对象。通过使用这个Entry <K,V>对象,我们可以根据值来排序HashMap。


2.创建一个简单的HashMap,并插入一些键和值。

[java] view plain copy
 print?
  1. Map<String,Integer> aMap = new HashMap<String,Integer>();  
  2.   
  3.         // adding keys and values  
  4.         aMap.put("Five"5);  
  5.         aMap.put("Seven"7);  
  6.         aMap.put("Eight"8);  
  7.         aMap.put("One",1);  
  8.         aMap.put("Two",2);  
  9.         aMap.put("Three"3);  

3.从HashMap恢复entry集合,如下所示。

[html] view plain copy
 print?
  1. Set<Entry<String,Integer>> mapEntries = aMap.entrySet();  


4.从上述mapEntries创建LinkedList。我们将排序这个链表来解决顺序问题。我们之所以要使用链表来实现这个目的,是因为在链表中插入元素比数组列表更快。

[java] view plain copy
 print?
  1. List<Entry<String,Integer>> aList = new LinkedList<Entry<String,Integer>>(mapEntries);  

5.通过传递链表和自定义比较器来使用Collections.sort()方法排序链表。

[java] view plain copy
 print?
  1. Collections.sort(aList, new Comparator<Entry<String,Integer>>() {  
  2.   
  3.             @Override  
  4.   
  5.             public int compare(Entry<String, Integer> ele1,  
  6.   
  7.                     Entry<String, Integer> ele2) {  
  8.   
  9.                 return ele1.getValue().compareTo(ele2.getValue());  
  10.   
  11.             }  
  12.   
  13.         });  

6.使用自定义比较器,基于entry的值(Entry.getValue()),来排序链表。

7. ele1.getValue(). compareTo(ele2.getValue())——比较这两个值,返回0——如果这两个值完全相同的话;返回1——如果第一个值大于第二个值;返回-1——如果第一个值小于第二个值。

8. Collections.sort()是一个内置方法,仅排序值的列表。它在Collections类中重载。这两种个方法是

[java] view plain copy
 print?
  1. public static <T extends Comparable<? super T>> void sort(List<T> list)  
  2.   
  3. public static <T> void sort(List<T> list, Comparator<? super T> c)  


9.现在你已经排序链表,我们需要存储键和值信息对到新的映射中。由于HashMap不保持顺序,因此我们要使用LinkedHashMap。

[java] view plain copy
 print?
  1. Map<String,Integer> aMap2 = new LinkedHashMap<String, Integer>();  
  2.         for(Entry<String,Integer> entry: aList) {  
  3.             aMap2.put(entry.getKey(), entry.getValue());  
  4.         }  


10.完整的代码如下。

[java] view plain copy
 print?
  1. package com.speakingcs.maps;  
  2.   
  3. import java.util.Collections;  
  4. import java.util.Comparator;  
  5. import java.util.HashMap;  
  6. import java.util.LinkedHashMap;  
  7. import java.util.LinkedList;  
  8. import java.util.List;  
  9. import java.util.Map;  
  10. import java.util.Map.Entry;  
  11. import java.util.Set;  
  12.   
  13. public class SortMapByValues {  
  14.   
  15.     public static void main(String[] args) {  
  16.   
  17.         Map<String,Integer> aMap = new HashMap<String,Integer>();  
  18.   
  19.         // adding keys and values  
  20.         aMap.put("Five"5);  
  21.         aMap.put("Seven"7);  
  22.         aMap.put("Eight"8);  
  23.         aMap.put("One",1);  
  24.         aMap.put("Two",2);  
  25.         aMap.put("Three"3);  
  26.   
  27.         sortMapByValues(aMap);  
  28.   
  29.     }  
  30.   
  31.     private static void sortMapByValues(Map<String, Integer> aMap) {  
  32.   
  33.         Set<Entry<String,Integer>> mapEntries = aMap.entrySet();  
  34.   
  35.         System.out.println("Values and Keys before sorting ");  
  36.         for(Entry<String,Integer> entry : mapEntries) {  
  37.             System.out.println(entry.getValue() + " - "+ entry.getKey());  
  38.         }  
  39.   
  40.         // used linked list to sort, because insertion of elements in linked list is faster than an array list.   
  41.         List<Entry<String,Integer>> aList = new LinkedList<Entry<String,Integer>>(mapEntries);  
  42.   
  43.         // sorting the List  
  44.         Collections.sort(aList, new Comparator<Entry<String,Integer>>() {  
  45.   
  46.             @Override  
  47.             public int compare(Entry<String, Integer> ele1,  
  48.                     Entry<String, Integer> ele2) {  
  49.   
  50.                 return ele1.getValue().compareTo(ele2.getValue());  
  51.             }  
  52.         });  
  53.   
  54.         // Storing the list into Linked HashMap to preserve the order of insertion.   
  55.         Map<String,Integer> aMap2 = new LinkedHashMap<String, Integer>();  
  56.         for(Entry<String,Integer> entry: aList) {  
  57.             aMap2.put(entry.getKey(), entry.getValue());  
  58.         }  
  59.   
  60.         // printing values after soring of map  
  61.         System.out.println("Value " + " - " + "Key");  
  62.         for(Entry<String,Integer> entry : aMap2.entrySet()) {  
  63.             System.out.println(entry.getValue() + " - " + entry.getKey());  
  64.         }  
  65.   
  66.     }  
  67. }  
阅读更多
个人分类: java
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

关闭
关闭
关闭