ArrayList排序练习二

排序与算法是考验一个程序员的基础能力是否牢固，在面试中常常出现，希望博主的两个小练习对你有帮助...加油！

实体类：

package cn.com.collections.sort;
/*
 * 第一种称为自然排序,参与排序的对象需实现comparable接口,重写其compareTo()方法,方法体中实现对象的比较大小规则,示例如下: 
实体类:(基本属性,getter/setter方法,有参无参构造方法,toString方法)
 */
//implements Comparable<Student>
public class Student {
	private String name;//姓名
	private int age;//年龄
	private String job;//职位
	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;
	}
	public String getJob() {
		return job;
	}
	public void setJob(String job) {
		this.job = job;
	}
	//无参构造 
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	//有参构造 
	public Student(String name, int age, String job) {
		super();
		this.name = name;
		this.age = age;
		this.job = job;
	}
	//tostring
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + ", job=" + job + "]";
	}
	/*public int compareTo(Student s) {
		if (s instanceof Student) {
			Student student=(Student)s;
			//return this.age - student.getAge();// 按照年龄升序排序
			return this.name.compareTo(student.getName());//按照姓名升序排序
		}
		//否则抛出类型转换异常
		throw new ClassCastException("不能转换为Student类型的对象...");
	}*/
	

}

测试类：

package cn.com.collections.sort;

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

import org.junit.BeforeClass;
import org.junit.Test;
/*
 * 第二种叫定制排序,或自定义排序,需编写匿名内部类,先new一个Comparator接口的比较器对象c,同时实现compare()其方法; 
然后将比较器对象c传给Collections.sort()方法的参数列表中,实现排序功能;
*/

//学生简单测试类
public class StudentTest {
	public static void main(String[] args) {
		//bianli1();
		 bianli2();
		// init();// 测试排序的时候，这个初始方法需要放开执行
		// testSortAge();///** 按age升序排序 */
	}

	// 抽取两个公用的
	static ArrayList<Student> list = new ArrayList<Student>();

	// @BeforeClass注解标注的方法会在其它测试方法执行之前先执行,
	// 且只执行一次.@Before注解标注的方法会在每个测试方法之前执行;
	// 此处初始化集合只需要一次,因此使用@BeforeClass.
	@BeforeClass
	public static void init() {
		list.add(new Student("小明", 20, "文艺委员"));
		list.add(new Student("小张", 20, "组长"));
		list.add(new Student("小红", 18, "班长"));
		list.add(new Student("小强", 22, "学习委员"));
		System.out.println("排序前:");
		for (Student student : list) {
			System.out.println(student);
		}
	}

	// 遍历学生1 增强for方式
	public static void bianli1() {
		Student student1 = new Student("小明", 20, "文艺委员");
		Student student2 = new Student("小张", 20, "组长");
		Student student3 = new Student("小红", 18, "班长");
		Student student4 = new Student("小强", 22, "学习委员");
		ArrayList<Student> list = new ArrayList<Student>();
		list.add(student1);
		list.add(student2);
		list.add(student3);
		list.add(student4);
		System.out.println("排序前:方式一增加for");
		// 增强for循环遍历
		for (Student student : list) {
			System.out.println(student);
		}
		// 2 使用get方法遍历
		System.out.println("2 使用get方法遍历");
		for (int i = 0; i < list.size(); i++) {
			Student student = list.get(i);
			System.out.println(student);
		}
		// 3 通过迭代器遍历循环
		System.out.println("3 通过迭代器遍历循环");
		Iterator<Student> it = list.iterator();// 获取迭代器
		while (it.hasNext()) {// 调用迭代器的hasNext方法判断是否有下一个元素
			Student student = it.next();// 调用迭代器的next获取下一个元素
			System.out.println(student);
		}
	}

	// 还是增强for遍历，换个方式写的
	public static void bianli2() {
		ArrayList<Student> list = new ArrayList<Student>();
		list.add(new Student("小明", 20, "文艺委员"));
		list.add(new Student("小张", 20, "组长"));
		list.add(new Student("小红", 18, "班长"));
		list.add(new Student("小强", 22, "学习委员"));
		System.out.println("排序前:方式二");
		for (Student student : list) {
			System.out.println(student);
		}
		// 2 使用get方法遍历
		System.out.println("2 使用get方法遍历");
		for (int i = 0; i < list.size(); i++) {
			Student student = list.get(i);
			System.out.println(student);
		}
		// 3 通过迭代器遍历循环
		System.out.println("3 通过迭代器遍历循环");
		Iterator<Student> it = list.iterator();
		while (it.hasNext()) {
			Student student = (Student) it.next();
			System.out.println(student);
		}
	}

	/** 按age升序排序 */
	/*@Test
	public  void testSortAge() {
		Collections.sort(list);
		System.out.println("自然排序按age排序后:");
		for (Student student : list) {
			System.out.println(student);
		}
	}*/
	/**按name升序排序*/
   /* @Test
    public void testSortName(){
        Collections.sort(list);
        System.out.println("自然排序按name升序排序后:");
        for (Student student : list) {
			System.out.println(student);
		}
    }*/
    //注意，以上这两种排序第一种方法不够灵活,实体类实现了comparable接口后,会增加耦合,如果在项目中不同的位置需要根据不同的属性调用排序方法时,需要反复修改比较规则(按name还是按age),二者只能选择其一,会起冲突.第二种就很好地解决了这个问题.在需要的地方,创建个内部类的实例,重写其比较方法即可.

    /**使用Comparator比较器按age升序排序*/
    @Test  //如果通过main方法调用的话，void前面需要添加static关键字，表示共享
    public void testComparatorSortAge(){
    	//通过1： Collections.sort()方法排序，
    	//2:创建一个比较器，实现比较的方法，
    	//3:最后遍历输出比较后的排序
    	//创建一个比较器
    	Collections.sort(list,new Comparator<Student>() {
			public int compare(Student s1, Student s2) {
				if (s1 instanceof Student && s2 instanceof Student) {
					Student e1 = (Student) s1;
    				Student e2 = (Student) s2;
    				return e1.getAge() - e2.getAge();//按照年龄升序排序
				}
				throw new ClassCastException("不能转换为Student类型");
			}
		});
		System.out.println("使用Comparator比较器按age升序排序后2:");
		for (Student student : list) {
			System.out.println(student);
		}
    }	
    /**使用Comparator比较器按age升序排序*/
    @Test  //如果通过main方法调用的话，void前面需要添加static关键字，表示共享
    public void testComparatorSortName(){
    	//通过1： Collections.sort()方法排序，
    	//2:创建一个比较器，实现比较的方法，
    	//3:最后遍历输出比较后的排序
    	//创建一个比较器
    	Collections.sort(list,new Comparator<Student>() {
    		public int compare(Student s1, Student s2) {
    			if (s1 instanceof Student && s2 instanceof Student) {
    				Student e1 = (Student) s1;
    				Student e2 = (Student) s2;
    				return e2.getName().compareTo(e1.getName());//按照姓名升序排序 h m qz
    				//return e1.getName().compareTo(e2.getName());//按照姓名倒序排序 z q m h
    			}
    			throw new ClassCastException("不能转换为Student类型");
    		}
    	});
    	System.out.println("使用Comparator比较器按姓名升序排序后:");
    	for (Student student : list) {
    		System.out.println(student);
    	}
    }	
    //这里按照职位测试，没有测试出预期的结果 ，可能是不能识别这个职位的大小，需要另写逻辑，博主这里暂时就这样，不知怎么写了
    //如有知道怎么测试这个方法的，可以留言给大家参考学习
    /**使用Comparator比较器按job升序排序*/
    @Test  //如果通过main方法调用的话，void前面需要添加static关键字，表示共享
    public void testComparatorSortJob(){
    	//通过1： Collections.sort()方法排序，
    	//2:创建一个比较器，实现比较的方法，
    	//3:最后遍历输出比较后的排序
    	//创建一个比较器
    	Collections.sort(list,new Comparator<Student>() {
    		public int compare(Student s1, Student s2) {
    			if (s1 instanceof Student && s2 instanceof Student) {
    				Student e1 = (Student) s1;
    				Student e2 = (Student) s2;
    				return e1.getJob().compareTo(e2.getJob());//按照职位升序排序
    				//return e2.getJob().compareTo(e1.getJob());//按照职位倒序排序
    			}
    			throw new ClassCastException("不能转换为Student类型");
    		}
    	});
    	System.out.println("使用Comparator比较器按job排序后:");
    	for (Student student : list) {
    		System.out.println(student);
    	}
    }	
}