java集合排序Collections.sort();Comparable;Comparator

[size=x-large][color=brown]一、Collections集合排序：[/color][/size]
Collections的集合类包含了排序方法 void sort(List<T> list)但是只能对List进行排序
[size=large][color=red]List[/color][/size]
ArrayList是按照添加顺序存储的
LinkedList也是按照添加顺序存储的
①对List进行正常排序

List<String> list = new ArrayList<String>();
list.add("12");
list.add("4");
list.add("23");
//Collections.sort(list);
Collections.sort(list, new Comparator<String>() {
	@Override
	public int compare(String o1, String o2) {
		int x1 = Integer.parseInt(o1);
		int x2 = Integer.parseInt(o2);
		return x1>x2?1:(x1==x2?0:-1);
	}
});
for(String info : list){
	System.out.println(info);
}

String类底层实现了Comparable接口，所以默认sort()排序是升序排列的。
如果排序规则不满足需求，需要使用sort(List<T> list, Comparator<? super T> c)构造器自己来实现排序规则(如上代码)
②List<Object>泛型为自定义对象时
可以通过上面方式外部实现排序接口Comparator
也可以在自定义对象中事先内部排序接口Comparable

package com.sunyuqian.test;

public class Person implements Comparable<Person>{
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public int compareTo(Person o) {
		return (o.getAge()<this.age)?1:((o.getAge()==this.age)?0:-1);
	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
}

//通过实体类实现comparable接口来实现内部排序
Person a = new Person("张三",23);
Person b = new Person("王五",43);
Person c = new Person("李四",12);
List<Person> plist = new ArrayList<Person>();
plist.add(a);
plist.add(b);
plist.add(c);
Collections.sort(plist);
for(Person info : plist){
	System.out.println(info.getName()+"--------"+info.getAge());
}

[size=large][color=red]set[/color][/size]
HashSet是无序的
LinkedHashSet按照添加顺序访问
TreeSet是可以对set集合进行自定义排序的

//Set<String>的泛型是基本类型时，默认实现了Comparable接口
//默认是按升序排列的
Set<String> treeSet = new TreeSet<String>();
treeSet.add("18");
treeSet.add("4");
treeSet.add("2");
treeSet.add("16");
treeSet.add("18");
treeSet.add("23");
for(String info : treeSet){
	System.out.println(info);
}

//如果不想按升序进行排序，就需要使用TreeSet(Comparator<? super E> comparator)的构造器，自己重新编写排序规则
//set降序输出
Set<String> treeSet = new TreeSet<String>(new Comparator<String>() {
	@Override
	public int compare(String o1, String o2) {
		return o2.compareTo(o1);
	}
});
treeSet.add("18");
treeSet.add("4");
treeSet.add("2");
treeSet.add("16");
treeSet.add("18");
treeSet.add("23");
for(String info : treeSet){
	System.out.println(info);
}
//如何泛型不是基本数据类型的包装类，而是自定义的对象，需要自定义的对象实现Comparable接口或者TreeSet实现外部接口

TreeSet是可以实现Comparator排序接口进行自定义排序规则的。如果不实现该接口默认是按泛型的本身自带的规则进行排序的。


[size=x-large][color=brown]二、Map集合排序：[/color][/size]
HashMap无序的
LinkedHashMap按照添加顺序存储的
TreeMap可以实现外部排序接口，默认升序


如果不使用TreeMap需要对HashMap进行排序，可以把Map放到List中使用Collections工具类对HashMap进行key排序或value排序

Map<String,String> map = new HashMap<String, String>();
map.put("1", "ccccccccc");
map.put("4", "aaaaaaaaa");
map.put("2", "ddddddddd");
map.put("3", "bbbbbbbbb");
List<Map.Entry<String,String>> mapList = new ArrayList<Map.Entry<String,String>>(map.entrySet());
Collections.sort(mapList, new Comparator<Map.Entry<String, String>>() {
	@Override
	public int compare(Entry<String, String> o1,
			Entry<String, String> o2) {
		return o1.getKey().compareTo(o2.getKey());
	}
});

for(Map.Entry<String, String> info : mapList){
	System.out.println(info.getKey()+"--------"+info.getValue());
}

[size=x-large][color=brown]三、Comparable与Comparator区别[/color][/size]

Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。

而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。