关于List<T> 的排序

/**
 * @author hjn
 * @entity Student
 * @date   2017年5月23日15:22:18
 */
public class Student {
	private String stuName;
	private String stuSex;
	private Integer stuAge;

	public Student() {
	}
	public Student(String stuName, String stuSex, Integer stuAge) {
		super();
		this.stuName = stuName;
		this.stuSex = stuSex;
		this.stuAge = stuAge;
	}

	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	public String getStuSex() {
		return stuSex;
	}
	public void setStuSex(String stuSex) {
		this.stuSex = stuSex;
	}
	public Integer getStuAge() {
		return stuAge;
	}
	public void setStuAge(Integer stuAge) {
		this.stuAge = stuAge;
	}
	@Override
	public String toString() {
		return "学生 [姓名=" + stuName + ", 性别=" + stuSex + ", 年龄=" + stuAge + "]";
	}

}

　　

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * @author hjn
 * @class  TestList
 * @date   2017年5月23日15:24:18
 */
public class TestList {

	public static void main(String[] args) {

		Student stu1=new Student("张三","男",25);
		Student stu2=new Student("李四","男",22);
		Student stu3=new Student("王五","男",26);
		Student stu4=new Student("赵六","男",25);
		Student stu5=new Student("麻七","男",28);
		Student stu6=new Student("二狗","男",21);
		List<Student> list=new ArrayList<Student>();
		list.add(stu1);list.add(stu2);
		list.add(stu3);list.add(stu4);
		list.add(stu5);list.add(stu6);

		System.out.println("排序前：");
		for (Student student : list) {
			System.out.println(student.toString());
		}

		Collections.sort(list, new Comparator<Student>(){

			@Override
			public int compare(Student o1, Student o2) {
				if(o1.getStuAge()>o2.getStuAge()){
					return 1;
				}
				if(o1.getStuAge()==o2.getStuAge()){
					return 0;
				}
				return -1;
			}
		});
		System.out.println("排序后：");
		for (Student student : list) {
			System.out.println(student.toString());
		}

	}

}

　　输出结果：

排序前：
学生 [姓名=张三, 性别=男, 年龄=25]
学生 [姓名=李四, 性别=男, 年龄=22]
学生 [姓名=王五, 性别=男, 年龄=26]
学生 [姓名=赵六, 性别=男, 年龄=25]
学生 [姓名=麻七, 性别=男, 年龄=28]
学生 [姓名=二狗, 性别=男, 年龄=21]
排序后：
学生 [姓名=二狗, 性别=男, 年龄=21]
学生 [姓名=李四, 性别=男, 年龄=22]
学生 [姓名=张三, 性别=男, 年龄=25]
学生 [姓名=赵六, 性别=男, 年龄=25]
学生 [姓名=王五, 性别=男, 年龄=26]
学生 [姓名=麻七, 性别=男, 年龄=28]

Collections的sort方法：

public static <T extends Comparable<? supper T>> void sort(List<T> list)

根据元素的自然顺序 对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable接口。此外，列表中的所有元素都必须是可相互比较的。也就是说对于列表中的任何e1和e2元素，e1.compareTo(e2)不得抛出ClassCastException。

此排序方法具有稳定性，不会因为调用sort方法而对相等的元素进行重新排序。
指定列表必须是可修改的，但不必是大小可调整的。
该排序算法是一个经过修改的合并排序算法，其中 如果低子列表中的最高元素小鱼高子列表中的最低元素，则忽略合并。此算法提供可摆正的n log（n）性能。此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置处每个元素的列表上进行迭代。这避免了由于试图原地对链接列表进行排序而产生的n² log（n）性能。

抛出 ClassCastException ---如果列表包含不可相互比较的元素 例如 字符串和整数。
抛出 UnsupportedOperationException ---如果指定列表的列表迭代器不支持set操作。

　　

public static <T> void sort(List<T> list , Comparable<? supper T> c)

根据指定比较器产生的顺序对指定列表进行排序。此列标内的所有元素都必须可使用指定比较器相互比较 也就是说 对于列表中的任意 e1 和e2元素，c.compare(e1,e2)不得抛出ClassCastException。

次排序被保证是稳定的，不会因调用sort而对相等的元素进行重新排序。
排序算法是一个经过修改的合并排序算法 其中 如果低子列表中的最高元素小鱼高子列表中的最低元素，则忽略合并。此算法提供可摆正的n log（n）性能。指定列表必须是可修改的，但不鄙视可大小调整的。此实现将指定列表转储到一个数组中，并对数组进行排序，在重置数组中相应位置每个元素的列表上进行迭代。这避免了由于试图原地对链接列表进行排序而产生的n? log（n）性能。

抛出 ClassCastException ---如果列表包含不可使用指定比较器相互比较的元素。
抛出 UnsupportedOperationException ---如果指定列表的列表迭代器不支持set操作。

接口 Comparator<T>

public interface Comparator<T>

强行对某个对象 collection 进行整体排序的比较函数。可以将Comparator传递给sort方法 例如：Collections.sort或Arrays.sort,从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构 （如 有序set 或有序映射） 的顺序，或者为那些没有自然顺序的对象collection提供排序。

当且仅当对于一组元素s中的每个e1和e2而言，c.compare(e1,e2)==0 与 e1..equals(e2)具有相等的布尔值时，Comparator c 强行对s进行的排序才叫做与equals一致的排序。

当使用具有与equals不一致的强行排序能力的Comparator 对有序set或有序映射进行排序时，应该小心谨慎。假定一个带显示Comparator c的有序set或有序映射与set S中抽取出来的元素或键一起使用。如果c强行对s进行的排序是与equals 不一致的，那么有序set或有序映射将是行为"怪异的"。尤其是有序set或有序映射 将违背根据equals 所定义的set或映射的常规协定。

例如 假定使用Comparator c 将满足（a.equals（b） && c.compare(a,b) !=0）的两个元素 a和b添加到一个空的TreeSet中，则第二个add将返回true(TreeSet的大小将会增加)，因为从TreeSet的角度来看，a，b是不相等的，即使这与 Set.add方法的规范相反。

注：通常来说，让Comparator也实现java.io.Serializable 是一个好主意 ，因为他们在序列化的数据结构 像TreeSet 、TreeMap中可用作排序方法。为了成功地序列化数据结构，Comparator必须实现Serializable。

在算数上，定义给定Comparator c 对给定对象set s实施强行排序的关系为：

{（x,y）such that c.compare(x,y)<=0}

在整体排序的系数（quotient）为

{（x,y）such that c.compare(x,y)==0}

它直接遵循compare 的协定，系数是s上的等价关系，强行排序时s上的整体排序。当我们说c强行对s的排序时与equals 一致是，意思是说排序的系数是对象的equals（Object）方法所定义的等价关系：

{（x,y）such that x,equals(y)}

Comparator的方法

int compare(T o1,T o2)

比较用来排序的两个参数。根据第一个参数小于等于或大于第二个参数分别返回负整数、零、或正整数。

抛出 ClassCastException --- 如果参数的类型不允许此Comparator 对他们进行比较。

boolean equals(Object obj)

指示某个其他对象是否"等于"此Comparator。此方法必须遵守Object.equals（Object）的常规协定。此外，仅当指定的对象也是一个Comparator，并且强行实施与此Comparator相同的排序时，此方法才返回true。

注意，不重写Object.equals(Object)方法总是安全的。然而，在某些情况下，重写此方法可以允许程序确定两个不同的Comparator是否强行实施了相同的排序，从而提高性能。