集合比较器|集合排序

List集合排序:

- Collections.sort(List);

sort方法的参数是一个List集合,对List集合中的数据排序
如果List集合中的元素,每个元素内部只有一个数据,就直接
比较即可,前提要保证元素中的数据类型,必须重写了compareTo方法
如果List集合中的元素,且每个元素中有很多的其他数据,就需要
把元素的类型实现Comparable接口,并重写CompareTo方法
在此方法中指定排序的原则.

灰常重要

Collections.sort(List,Comparator);

1. 匿名内部类—>
2. 直接 new 接口 后面给出具体的方法实现—>
3. 多态,new 出长辈类对象,调用子辈重写的方法—>
4. 子类中实现compare策略,
5. Collections.sort(List , Comparator)方法回调子类中重写的compare方法

sort方法的参数有两个,一个是要排序的list数据,
另一个参数是比较器接口Comparator接口,在此比较器中
执行要排序的原则,使用比较器的方式就不用对要比较的结合
中的元素类型实现Comparable接口
可以实现多个比较器,每个比较器对应一种排序原则

总结:
如果就一种排序原则,用Comparable接口
如果有多种比较原则,就用Comparator接口

例Collections.sort(List);

@Override//------>实现Comparable接口,并重写CompareTo方法
public int compareTo(Student o) {
	//给name排序
	int value=this.getName().compareTo(o.getName());
	//给age排序
	//int value=this.getAge()-o.getAge();
	//给stuNo排序
	//int value=this.getStuNo().compareTo(o.getStuNo());
	return value;
}

public void sortStudent(){
	ArrayList<Student> stus=new ArrayList<Student>();
	Student stu1=new Student("zhangsan",20,"S001");
	Student stu2=new Student("lisi",20,"S001");
	Student stu3=new Student("wangwu",20,"S001");
	stus.add(stu1);
	stus.add(stu2);
	stus.add(stu3);
	System.out.println("---------排序前-------------");
	for(Student stu : stus){
		System.out.println("name="+stu.getName()
		       +"  age="+stu.getAge()
		       +"  stuNo="+stu.getStuNo()); 
	}
	System.out.println("---------开始排序-------------");
	Collections.sort(stus);//------->需要在Student类中实现Comparable接口,并重写CompareTo方法
	System.out.println("---------排序后-------------");
	for(Student stu : stus){
		System.out.println("name="+stu.getName()
		       +"  age="+stu.getAge()
		       +"  stuNo="+stu.getStuNo()); 
	}
}

例: Collections.sort(List,Comparator);

//此方法是为了获取一个List集合
public List<Teacher> getTeachers(){
	ArrayList<Teacher> teas=new ArrayList<Teacher>();
	Teacher tea1=new  Teacher("zhangsan",21,18000);
	Teacher tea2=new  Teacher("lisi",20,15000);
	Teacher tea3=new  Teacher("王五",22,20000);
	teas.add(tea1);
	teas.add(tea2);
	teas.add(tea3);
	return teas;
}
//排序,根据指定Comparator的排序原则,按名称排序的策略实现
public void sortName(List<Teacher> teas){
	Collections.sort(teas,new Comparator<Teacher>(){//回调compare方法
		//匿名内部类 --->多态--->策略设计模式
		@Override
		public int compare(Teacher o1, Teacher o2) {
			int value=o1.getName().compareTo(o2.getName());
			return value;
		}
		
	});
}
//排序,根据指定Comparator的排序原则,按年龄排序的策略实现
public void sortAge(List<Teacher> teas){
	Collections.sort(teas,new Comparator<Teacher>(){

		@Override
		public int compare(Teacher o1, Teacher o2) {
			int value=o1.getAge()-o2.getAge();
			return value;
		}
		
	});
}
//排序,根据指定Comparator的排序原则,按年龄排序的策略实现
public void sortSalary(List<Teacher> teas){
	Collections.sort(teas,new Comparator<Teacher>(){

		@Override
		public int compare(Teacher o1, Teacher o2) {
			int value=o1.getSalary()-o2.getSalary();
			return value;
		}
		
	});
}