Java List/HashSet/HashMap的排序_listhashmap排序-优快云博客

前言·：

在对Java无序类集合，如List（ArrayList/LinkedList）、HashSet（TreeSet有序）、HashMap等排序时，Java中一个公共的类Collections，提供了对Java集合排序等很好的方法sort。但是有一个要求是sort方法的参数为<List list> 或<List list, Comparator<? super T> c>，即排序对象要求必须是List类型。

sort 方法的参数必须为List 的原因是，只有List可以定义排序的方法，让List中的元素改变在构建List时原始的相对位置（初始构建时，元素相对位置即为元素初始加入顺序）。HashSet、HashMap 在构建时，初始加入的元素已经按照元素的hashCode()方法的定义排好序。所以这里所说的HashSet 排序和 HashMap 排序是指：将其中的元素导出到另一个集合中，对该载体集合排序。排序之后，原HashSet 和 HashMap 中元素顺序没有变。

故而对Java无序类集合的排序问题，基本思路就是：将HashSet 或 HashMap 中的元素取出放入 List 中，对List 用 Collections.sort() 方法排序，之后输出排序后List中的元素，即为对Set/Map 中元素排序后的结果。注意HashSet、HashMap 中元素位置没有改变，依然只和初始构建时，元素本身自定义的hashCode() 方法有关。

对HashSet 等可以重写元素类中的hashCode 等方法，实现自己想定义的排序机制。参考 HashSet,LinkedHashSet,TreeSet的内部排序

Java集合框架之小结由Java中的Set，List，Map引出的排序技巧

【源码前了无秘密】：Java 集合类源码：Thinking in Java之集合相关整理(源码分析) Java集合类源码分析汇总

Test例子：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;

public class Test {
	public static void main(String[] args){
		ArrayList<String> listTest = new ArrayList<String>();
		listTest.add("bbc");
		listTest.add("abc");
		listTest.add("acb");		
		
		HashSet<String> setTest = new HashSet<String>();
		setTest.add("bbc");
		setTest.add("abc");
		setTest.add("acb");
		System.out.println("HashSet BeforeSort:");
		for(String s : setTest)
			System.out.println(s);
		
		HashMap<String, Integer> mapTest = new HashMap<String, Integer>();
		mapTest.put("bbc", 1);
		mapTest.put("abc", 2);
		mapTest.put("acb", 3);
		System.out.println("HashMap BeforeSort:");
		for(Map.Entry<String, Integer> entry : mapTest.entrySet())
			System.out.println(entry.getKey() + " " + entry.getValue());
		
		/*
		 * List 
		 */
		Collections.sort(listTest);
		Iterator<String> list_iter = listTest.iterator();
		while(list_iter.hasNext())
			System.out.println(list_iter.next());
		
		/*
		 * Set
		 */		
		LinkedList<String> setSort = new LinkedList<String>(setTest);		
		//Collections.sort(setSort);
		Comparator<String> setComp = Collections.reverseOrder();
		Collections.sort(setSort, setComp);
		/*LinkedList<String> setSort = new LinkedList<String>();
		for(String s : setTest)
			setSort.add(s);*/
		for(String s : setTest)
			System.out.println(s);
		for(String s : setSort)
			System.out.println(s);	
		
		/*
		 * Map
		 */		
		LinkedList<String> mapSort = new LinkedList<String>();
		mapSort.addAll(mapTest.keySet());
		//Collections.sort(mapSort);
		Comparator<String> mapComp = Collections.reverseOrder();
		Collections.sort(mapSort, mapComp);
		for(Map.Entry<String, Integer> entry : mapTest.entrySet())
			System.out.println(entry.getKey() + " " + entry.getValue());
		for(final Iterator<String> map_iter= mapSort.iterator(); map_iter.hasNext();)
			System.out.println(map_iter.next());		
/*		
		LinkedList<Map.Entry<String, Integer>> mapEntry = new LinkedList<Map.Entry<String,Integer>>();
		mapEntry.addAll(mapTest.entrySet());
		Collections.sort(mapEntry, new Comparator<Map.Entry<String, Integer>>() {
			public int compare(Map.Entry<String, Integer> a, Map.Entry<String, Integer> b){
				if(a.getValue() > b.getValue())
					return -1;
				else
					return 1;				
			}
		});		
		
		for(Map.Entry<String, Integer> entry : mapEntry)
			System.out.println(entry.getKey() + " " +entry.getValue());
		for(Map.Entry<String, Integer> entry : mapTest.entrySet())
			System.out.println(entry.getKey() + " " + entry.getValue());*/		
	}
}

输出结果：

HashSet BeforeSort:
abc
acb
bbc
HashMap BeforeSort:
abc 2
acb 3
bbc 1
//List AfterSort
abc
acb
bbc
//HashSet AfterSort
abc
acb
bbc
//setSort AfterSort (setSort is means HashSet to LinkedList)
bbc
acb
abc
//HashMap AfterSort
abc 2
acb 3
bbc 1
//mapSort AfterSort (mapSort is means HashMap to LinkedList)
bbc
acb
abc

参考原文《HashMap的排序》地址： http://hi.baidu.com/wenzheng38/item/0c2ed5c52303127388ad9efd 内容如下：

一、按key值排序

假设HashMap存储的键-值对为（String，Integer），按key排序可以调用JDK函数sort（默认的按字典升序）：
Set<String> keySet = map.keySet();
Collections.sort(keySet);
for(Iterator<String> ite = keySet.iterator(); ite.hasNext();) {
String temp = ite.next();
System.out.println("key-value: "+temp+","+map.getValue(temp);
}
如果想要按字典的降序排列，则需改写sort方法里面的比较器Comparator：
Collections.sort(keySet, new Comparator() {
public int compare(Object o1, Object o2) {
if(Integer.parseInt(o1.toString())>Integer.parseInt(o2.toString())
return 1;
if(Integer.parseInt(o1.toString())==Integer.parseInt(o2.toString())
return 0;
else
return -1;
}
});

二、按value值排序

1)方法一：用两个list链表实现
List<String> keyList = new LinkedList<String>();
keyList.addAll(map.keySet());
List<Integer> valueList = new LinkedList<Integer>();
valueList.addAll(map.values());
for(int i=0; i<valueList.size(); i++)
for(int j=i+1; j<valueList.size(); j++) {
if(valueList.get(j)>valueList.get(i)) {
valueList.set(j, valueList.get(i));
valueList.set(i, valueList.get(j));
//同样调整对应的key值
keyList.set(j, keyList.get(i));
keyList.set(i, kyeList.get(j));
}
然后依次把key值和对应value值重新装入HashMap即可。
2）方法二：改写JDK提供的Comparator接口方法compare
List<Map.Entry<String, Integer>> list = new LinkedList<Map.Entry<String, Integer>>();
list.addAll(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
public int compare(Map.Entry obj1, Map.Entry obj2) {//从高往低排序

if(Integer.parseInt(obj1.getValue().toString())<Integer.parseInt(obj2.getValue().toString()))
return 1;
if(Integer.parseInt(obj1.getValue().toString())==Integer.parseInt(obj2.getValue().toString()))
return 0;
else
return -1;
}
});
for(Iterator<Map.Entry<String, Integer>> ite = list.iterator(); ite.hasNext();) {
Map.Entry<String, Integer> map = ite.next();
System.out.println("key-value: " + map.getKey() + "," + map.getValue());
}