实现Collections.sort自然排序，以及重写Collections.sort，对实体类中的两个字段进行排序。

#collectionSort 工具类
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
/**

• 1.重写Collections.sort(List list, Comparator<? super T> c){},对实体类中的两个字段进行排序。
• 2.Collections.sort自然排序
• @author JungleKao

*/
public class collectionSort {

public static void main(String[] args) {
	List<String> lstr = new ArrayList<>();
	lstr.add("2");
	lstr.add("5");
	lstr.add("3");
	AscString(lstr);
	System.out.println("对String类型的集合进行升序排序的结果：");
	for(String str : lstr) {
		System.out.println(str);
	}
	
	List<Students> ls = new ArrayList<>();
	ls.add(new Students(15, 97));
	ls.add(new Students(16, 95));
	ls.add(new Students(17, 90));
	ls.add(new Students(16, 100));
	ls.add(new Students(15, 95));
	
	System.out.println("按age升序排序，score升序排序所得结果：");
	AscAgeAscScore(ls);
	for(Students s : ls) {
		System.out.println(s.getAge() + "、" + s.getScore());
	}
	
	System.out.println("按age升序排序，score降序排序所得结果：");
	AscAgeDescScore(ls);
	for(Students s : ls) {
		System.out.println(s.getAge() + "、" + s.getScore());
	}
	
	System.out.println("按age降序排序，score降序排序所得结果：");
	DescAgeDescScore(ls);
	for(Students s : ls) {
		System.out.println(s.getAge() + "、" + s.getScore());
	}
	
	DescAgeAscScore(ls);
	System.out.println("按age降序排序，score升序排序所得结果：");
	for(Students s : ls) {
		System.out.println(s.getAge() + "、" + s.getScore());
	}
}

/**
 * 	按age升序排序，score升序排序
 * @param list
 * @return
 */
public static List<Students> AscAgeAscScore(List<Students> list){		
	Collections.sort(list, new Comparator<Students>() {
		
		@Override
		public int compare(Students o1, Students o2) {
			// 按age升序排序
			int i = o1.getAge() - o2.getAge();
			
			// 如果age的值相等，则按score升序排序
			if (i == 0) {
				//返回score升序排序的值
				return o1.getScore() - o2.getScore();
			}
			//返回age升序排序的值
			return i;
		}
		
	});
	return list;
}

/**
 * 	按age升序排序，score降序排序
 * @param list
 * @return
 */
public static List<Students> AscAgeDescScore(List<Students> list){		
	Collections.sort(list, new Comparator<Students>() {
		
		@Override
		public int compare(Students o1, Students o2) {
			// 按age升序排序
			int i = o1.getAge() - o2.getAge();
			
			// 如果age的值相等，则按score降序排序
			if (i == 0) {
				//返回score降序排序的值
				return o2.getScore() - o1.getScore();
			}
			//返回age升序排序的值
			return i;
		}
		
	});
	return list;
}

/**
 * 	按age降序排序，score降序排序
 * @param list
 * @return
 */
public static List<Students> DescAgeDescScore(List<Students> list){		
	Collections.sort(list, new Comparator<Students>() {
		
		@Override
		public int compare(Students o1, Students o2) {
			// 按age降序排序
			int i = o2.getAge() - o1.getAge();
			
			// 如果age的值相等，则按score降序排序
			if (i == 0) {
				//返回score降序排序的值
				return o2.getScore() - o1.getScore();
			}
			//返回age降序排序的值
			return i;
		}
		
	});
	return list;
}

/**
 * 	按age升序排序，score升序排序
 * @param list
 * @return
 */
public static List<Students> DescAgeAscScore(List<Students> list){		
	Collections.sort(list, new Comparator<Students>() {
		
		@Override
		public int compare(Students o1, Students o2) {
			// 按age降序排序
			int i = o2.getAge() - o1.getAge();
			
			// 如果age的值相等，则按score升序排序
			if (i == 0) {
				//返回score升序排序的值
				return o1.getScore() - o2.getScore();
			}
			//返回age降序排序的值
			return i;
		}
		
	});
	return list;
}

/**
 * 	自然排序
 */
public static List<String> AscString(List<String> list){
	Collections.sort(list);
	return list;
}

}

#Students实体类
/**

• 学生类
• @author JungleKao

*/
public class Students {

private String name; // 姓名

private int score; // 成绩

private int age; // 年龄

public String getName() {
	return name;
}

public void setName(String name) {
	this.name = name;
}

public int getScore() {
	return score;
}

public void setScore(int score) {
	this.score = score;
}

public int getAge() {
	return age;
}

public void setAge(int age) {
	this.age = age;
}

Students(int age, int score){
	this.age = age;
	this.score = score;
}

}