8.3集合类Collections_collections.sort -1-优快云博客

1Collections

collections封装了对collection以及下面的子类处理方法

该类提供了一些很方便的方法，如在查找，排序元素等。
该类的方法都是静态的

1.1排序

栗子：

	public static void main(String[] args){
		//
		List list = new ArrayList();
		//往list中放元素，这个方法也可以为其他的集合类放元素如set
		//该类的方法都是static的，可以直接用类名调用
		Collections.addAll(list, "asd","fff","asd","dde","jjh");
		
		//排序(自然顺序)
		Collections.sort(list);
		//反向排序
		Collections.reverse(list);
	}

1.2对象排序

可以让对象类实现他的比较器Comparable<T>

栗子：

Student类

/*
 * 实现Comparable,
 * 注意的是里面的泛型必须是与list的相同
 * */
class Student implements Comparable<Student>{
	int number;	//学号
	String name;//名字
	int height;//身高
	
	//构造方法
	public Student(int number, String name, int height) {
		super();
		this.number = number;
		this.name = name;
		this.height = height;
	}

	
	//覆盖接口的方法
	//如果对象
	//返回值为于1就按正序排，返回值为-1就反着排,为0就相等
	@Override
	public int compareTo(Student s) {
		//先按学号排
		//用自己（this）的学号和s的学好比，如果大于，返回1的话就正着排，返回-1的话就会反着排
		if(this.number>s.number){
			return 1;					
		}else if(this.number<s.number){
			return -1;
		}else{
			return 0;
		}
	}

	
	//toString
	@Override
	public String toString() {
		return "Student [number=" + number + ", name=" + name + ", height=" + height + "]";
	}
}

main入口：

		//
		List<Student> list = new ArrayList<Student>();
		list.add(new Student(1, "八戒", 180));
		list.add(new Student(3, "悟空", 99999));
		list.add(new Student(2, "沙僧", 185));
		list.add(new Student(9, "师傅", 180));
		
		//排序对象，该对象类实现它的比较器Comparable，并继承comparaTo（）方法
		Collections.sort(list);
		
		//遍历list
		for(Student s:list){
			System.out.println(s);
		}
	}

输出结果是：

Student [number=1, name=八戒, height=180]
Student [number=2, name=沙僧, height=185]
Student [number=3, name=悟空, height=99999]
Student [number=9, name=师傅, height=180]

如果将this和对象比会大于返回的值为-1话，就会倒着排

修改了下Student类中覆盖的方法compareTo（T）方法，将this.number > s.number的返回值换成了-1，这样就会倒着排

	//覆盖接口的方法
	//如果对象
	//返回值为于1就按正序排，返回值为-1就反着排,为0就相等
	@Override
	public int compareTo(Student s) {
		//先按学号排
		//用自己（this）的学号和s的学好比，如果大于，返回1的话就正着排，返回-1的话就会反着排
		if(this.number>s.number){
			return -1;					
		}else if(this.number<s.number){
			return 1;
		}else{
			return 0;
		}
	}

输出结果：

Student [number=9, name=师傅, height=180]
Student [number=3, name=悟空, height=99999]
Student [number=2, name=沙僧, height=185]
Student [number=1, name=八戒, height=180]

如果要按名字来排呢

看栗子：再次修改Student类中覆盖的方法compareTo（T）方法

	public int compareTo(Student s) {
		//按名字来排序
		//String类实现了这个Comparable这个接，所以可以直接用调用这个方法来给String类型的排序(是anUnicode的值)
		return this.name.compareTo(s.name);
	}

1.3按不同的类型排序

这样做有个缺点，如果我下次要按身高来排序的话，有要跑到这个Studen类的内部来修改，修改内部类是有风险的

所以，sort（）方法可以传入一个Comparetor类型的参数来达到选折不同的排序方式

看例子：1，student类不用再实现Comparble接口

/*
 * 实现Comparable,
 * 注意的是里面的泛型必须是与list的相同
 * */
class Student{
	int number;	//学号
	String name;//名字
	int height;//身高
	
	//构造方法
	public Student(int number, String name, int height) {
		super();
		this.number = number;
		this.name = name;
		this.height = height;
	}
	
	//toString
	@Override
	public String toString() {
		return "Student [number=" + number + ", name=" + name + ", height=" + height + "]";
	}
}

2，写一个类实现Comparator接口

/*
 * 写一个类继承Comparator接口，实现其方法
 * */
class MyComparable implements Comparator<Student>{

	@Override
	public int compare(Student o1, Student o2) {
		return o1.height>o2.height?1:(o1.height<o2.height)?-1:0;//三目运算判断
	}
}

3mian：sort（）方法中传入一个Comparator类型的参数

		//排序对象，该对象类实现它的比较器Comparator
		Collections.sort(list,new MyComparable());

输出结果：

Student [number=1, name=八戒, height=180]
Student [number=9, name=师傅, height=180]
Student [number=2, name=沙僧, height=185]
Student [number=3, name=悟空, height=99999]

这就回按身高来排序了，如果还要实现像按年龄，班级排序等，就可以在写类实现Comparator比较器，然后再参入这个比较器，就不用再去类的内部修改代码