ArrayList排序练习二

末蓝、 2022-02-05 13:15 211阅读 0赞

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

实体类：

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);
        	}
        }	
    }