对各种数据类型(list,map)进行排序

首先，我们需要知道比较器Comparator的使用，其次才是对不同类型的排序。

Comparator 比较器的使用

compare（int o1, int o2）方法 return o1 - o2 是升序，return o2 - o1 是降序

传统方式的使用

一边是吧Comparator接口作为没写方法的参数，我们直接new 匿名内部类，在重写方法使用

Collections.sort(list, new Comparator<Student>() {
 @Override
 public int compare(Student o1, Student o2) {
   return o1.getAge()-o2.getAge();//以学生的年龄升序
 }
})；

自定义比较器的使用

自已一个类，来实现Comparator接口，重写方法

class NameComparator implements Comparator<Student>{
	@oVERRIDE
	public int compare(Student o1,Student o2)
	{
		if(o1.name.compareTo(o2.name)>0)
			return 1;
		else if(o1.name.compareTo(o2.name)<0)
			return -1;
		else 
			return o1.name.compareTo(o2.name);
	}
}

List集合

###单属性变量List -List,List

    Collections.sort(list); // 升序排列
    Collections.reverse(list); // 倒序排列
	// 自定义顺序排序
	Collections.sort(list, new Comparator<String>()
    {
        public int compare(String a1, String a2)
        {
                int io1 = sortRule.indexOf(a1);
                int io2 = sortRule.indexOf(a2);
                return io1 - io2;
        }
    });

实体类list- List

	// 1.按照单个属性排序
    list.sort(Comparator.comparing(Student::getScore)); // 升序
	// 降序
    list.sort(Comparator.comparing(Student::getScore).reversed());
	
	// 2.按照多个属性排序
	
   // 方法一 students.sort(Comparator.comparing(Student::getScore).reversed().thenComparing(Student::getHeight));
   // 方法二
    Collections.sort(students, new Comparator<Student>()
    {
        public int compare(Student student1, Student student2)
        {
            if(student1.getScore().equals(student2.getScore())){
                return student2.getHeight() - student1.getHeight();
            }else{
                return student2.getScore() - student1.getScore();
            }
        }
    });

对map的排序

HashMap：我们最常用的Map，它根据key的HashCode 值来存储数据,根据key可以直接获取它的Value，同时它具有很快的访问速度。HashMap最多只允许一条记录的key值为Null(多条会覆盖);允许多条记录的Value为 Null。非同步的。
TreeMap: 能够把它保存的记录根据key排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。
Hashtable: 与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。
LinkedHashMap: 保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，非同步的。

对TreeMap排序

TreeMap默认是升序的，如果我们需要改变排序方式，则需要使用比较器：Comparator。

对键进行排序

public class TreeMapTest {
    public static void main(String[] args) {
        Map<String, String> map = new TreeMap<String, String>(
                new Comparator<String>() {
                    public int compare(String obj1, String obj2) {
                        // 降序排序
                        return obj2.compareTo(obj1);
                    }
                });
	    // 给map赋值
        map.put("c", "ccccc");
        map.put("a", "aaaaa");
        map.put("b", "bbbbb");
        map.put("d", "ddddd");
        
		// 遍历map
        Set<String> keySet = map.keySet();
        Iterator<String> iter = keySet.iterator();
        while (iter.hasNext()) {
            String key = iter.next();
            System.out.println(key + ":" + map.get(key));
        }
    }
}

对值进行排序

public class TreeMapTest {
    public static void main(String[] args) {
        Map<String, String> map = new TreeMap<String, String>();
        map.put("d", "ddddd");
        map.put("b", "bbbbb");
        map.put("a", "aaaaa");
        map.put("c", "ccccc");
        
        //这里将map.entrySet()转换成list
        List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
        //然后通过比较器来实现排序
        Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
            //升序排序
            public int compare(Entry<String, String> o1,
                    Entry<String, String> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
            
        });
        
        for(Map.Entry<String,String> mapping:list){ 
               System.out.println(mapping.getKey()+":"+mapping.getValue()); 
          } 
    }
}

HashMap排序

hashmap是无序的

public class HashMapTest {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("c", "ccccc");
        map.put("a", "aaaaa");
        map.put("b", "bbbbb");
        map.put("d", "ddddd");
        
        List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
        Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
            //升序排序
            public int compare(Entry<String, String> o1,
                    Entry<String, String> o2) {
                return o1.getValue().compareTo(o2.getValue());
            }
            
        });
        
        for(Map.Entry<String,String> mapping:list){ 
               System.out.println(mapping.getKey()+":"+mapping.getValue()); 
          } 
     }
}