java中Comparable＜T＞与Comparator＜T＞的使用与区别

1.comparable的使用

comparable（内部比较器，比较属性，静态绑定）是一个排序接口，当某个类实现该接口后，该类就具备了排序的能力，前提是该类的属性具备排序的条件。实现comparable接口，Override接口的方法compareTo。一般来说，如果创建一个类，该类具有排序的属性，最好是实现该接口。
comparable接口的源码

现在我们就用一些具体的例子来说明comparable的使用。

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

/**
 * @author
 * @PackageName:PACKAGE_NAME
 * @ClassName:Student
 * @Description:
 * @date 2021-8-9 15:26
 */
public class Student implements Comparable<Student>{
    private Integer age;
    private String name;

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

    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;//升序排序
    }


    public static void main(String[] args) {
        System.out.println("================使用Arrays.sort=============");
        Student[] students = new Student[3];
        students[0] = new Student(18, "xiaoxian");
        students[1] = new Student(23, "huajuan");
        students[2] = new Student(3, "xiaobaby");
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));

        System.out.println("================使用Collections.sort=============");
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student(18, "xiaoxian"));
        list.add(new Student(23, "huajuan"));
        list.add(new Student(3, "xiaobaby"));
        Collections.sort(list);
        System.out.println(list);
    }
}

2.comparator的使用

comparator(外部比较器，比较器，动态绑定)是一个比较器。如果一个已经定义好了，不能修改时，但又想进行比较时，就可以使用该比较器进行排序。
comparator接口的源码

同样的我们用一些具体的例子来说明comparator的使用。

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

/**
 * @author
 * @PackageName:PACKAGE_NAME
 * @ClassName:Student2
 * @Description:
 * @date 2021-8-9 15:59
 */
public class Student2 {
    private Integer age;
    private String name;

    public Student2(Integer age, String name) {
        this.age = age;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student2{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }


    public static void main(String[] args) {
        System.out.println("================使用Arrays.sort=============");
        Student2[] students = new Student2[3];
        students[0] = new Student2(18, "xiaoxian");
        students[1] = new Student2(23, "huajuan");
        students[2] = new Student2(3, "xiaobaby");
        Arrays.sort(students, new Comparator<Student2>() {
            @Override
            public int compare(Student2 o1, Student2 o2) {
                if (o1 == null || o2 == null) {
                    return 0;
                }
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println(Arrays.toString(students));


        System.out.println("================使用Collections.sort=============");
        ArrayList<Student2> list = new ArrayList<>();
        list.add(new Student2(18, "xiaoxian"));
        list.add(new Student2(23, "huajuan"));
        list.add(new Student2(3, "xiaobaby"));
        Collections.sort(list, new Comparator<Student2>() {
            @Override
            public int compare(Student2 o1, Student2 o2) {
                if (o1 == null || o2 == null) {
                    return 0;
                }
                return o1.getAge() - o2.getAge();
            }
        });
        System.out.println(list);
    }
}

3.两者的区别

通过对两者的使用说明，相信聪明的你能够看出两者的区别了，在这里我再稍稍总结一下。
(1)Comparable＜T＞是内部比较器，比较属性，静态绑定；而Comparator＜T＞是外部比较器，比较器，动态绑定
(2)如果一个类具有可比较的属性的话，并且想对该类的对象进行排序，最好是实现Comparable＜T＞接口。如果某个类已经定义好了，不想再修改，并且又想自定义规则对该类的对象进行排序，可以创建一个比较器进行排序。