排序（Comparable和Comparator）

Comparable

Comparable接口会强行对实现它的每个类的对象进行整体排序，这种排序被称为类的自然排序。例如String类、包装类都实现了Comparable接口重写了CompareTo()方法，而且默认都是从小到大排列的。

代码实现：对学生类的年级从小到大排序

/**
*学生类
*/

public class Student implements Comparable<Student> {//实现Comparable类，并实现他的接口compareTo

    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

    /**
     * 实现Comparable的方法compareTo
     * 两个对象即通过compareTo(Sutdent student)方法的返回值来比较大小  compareTo(需要比较的实体类)
     * 	如果当前对象this大于形参对象student,则返回正整数
     * 	如果当前对象this小于形参对象student,则返回负整数
     * 	如果当前对象this等于形参对象student，则返回零
     * 	实现了Comparable接口的对象集合或数组可以通过Collections.sort()或Arrays.sort()进行排序（默认升序）
     * @param student
     * @return
     */
    @Override
    public int compareTo(Student student) {
        if(this.age>student.age){//这里是对age的排序
            return 1;
        }else if (this.age<student.age){
            return -1;
        }else {
            return 0;
        }
    }
}

实现类

/**
 *测试类
 */

public class StudentTest {
    public static void main(String[] args) {
        Student[] arr=new Student[4];
        arr[0]=new Student("张三",12);
        arr[1]=new Student("李四",10);
        arr[2]=new Student("王五",15);
        arr[3]=new Student("赵六",18);
        System.out.println("排序前--------");
        for (int i = 0; i <arr.length ; i++) {//遍历排序前的数组
            System.out.println(arr[i].getName()+"    "+arr[i].getAge());
        }
        Arrays.sort(arr);//对数组的排序
        System.out.println("排序后---------");
        for (int i = 0; i <arr.length ; i++) {//遍历排序后的数组
            System.out.println(arr[i].getName()+"    "+arr[i].getAge());
        }
    }
}

运行结果：

Comparator

当对象的类型没有实现Comparable接口而又不方便修改代码，或者实现了Comparable接口，但排序规则不适合当前的操作，那么可以考虑使用Comparator强行对多个对象进行整体排序。

代码实现：没有实现Comparable接口的学生类

/**
 * 学生类
 */
public class Student2 {
    private String name;//姓名
    private int score;//成绩

    public Student2(String name, int score) {
        this.name = name;
        this.score = score;
    }

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

/**
 * 对Comparator接口的实现 compare()方法
 */
public class StudentComparator implements Comparator<Student2> {
    /**
     * 
     * @param s1 第一个学生类
     * @param s2 第二个学生类
     * 当我们实现Comparator接口重写compare(Student2 s1,Student2 s2)方法比较o1和o2的大小
     * 	如果方法返回正整数，则表示是s1大于s2；
     * 	如果方法返回负整数，则表示是s1小于s2；
     *	如果方法返回正整数，则表示是s1等于s2；
     */
    @Override
    public int compare(Student2 s1, Student2 s2) {
        if (s1.getScore()>s2.getScore()){
            return 1;
        }else  if (s1.getScore()<s2.getScore()){
            return -1;
        }else {
            return 0;
        }
    }
}

/**
 * 测试类
 */
public class Studen2tTest {
    public static void main(String[] args) {
        Student2[] arr=new Student2[4];
        arr[0]=new Student2("张三",88);
        arr[1]=new Student2("李四",97);
        arr[2]=new Student2("王五",44);
        arr[3]=new Student2("赵六",32);
        System.out.println("排序前----");
        for (int i = 0; i <arr.length ; i++) {//排序前
            System.out.println(arr[i].getName()+"     "+arr[i].getScore());
        }
        Arrays.sort(arr,new StudentComparator());//排序  参数1：我们要排序的数组  参数2：是我们实现Comparator接口的类
        System.out.println("排序后----");
        for (int i = 0; i <arr.length ; i++) {//排序后
            System.out.println(arr[i].getName()+"     "+arr[i].getScore());
        }
    }
}

运行结果：