Comparable 和 Comparator区别小结

什么叫成熟，你妈没喊你，你就穿上秋裤了。什么叫青春，你妈一天念叨三回，你还是不穿秋裤— —所以到底秋裤是什么，秋装校服裤吗？

一、Comparable小结
Comparable是排序接口。若一个类实现了Comparable接口，就意味着该类支持排序。
实现了Comparable接口的类的对象的集合或数组，可以通过Collections.sort或Arrays.sort进行自动排序。

下面来举个栗子：
关于CompareTo()方法，如果返回的是this.age-s.age，则为升序排序；如果返回的是s.age-this.age，则为降序排序

public class Student implements Comparable<Student>{
    private String name;
    private int age;

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

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

    @Override
    public int compareTo(Student s) {
        return this.getAge()-s.getAge();
    }
}

使用了Collections.sort方法对集合中的Student进行排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Client {
    public static void main(String[] args) {
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",19);
        List<Student> list = new ArrayList<>(3);
        list.add(s1);
        list.add(s2);
        list.add(s3);

        System.out.println("排序前------------------");
        for (Student s:list) {
            System.out.println(s);
        }

        System.out.println("排序后------------------");
        Collections.sort(list);
        for (Student s:list) {
            System.out.println(s);
        }
    }
}

二、Comparator小结
Comparator是比较接口，如果需要控制某个类的次序，而该类本身没有实现Comparable接口，可以通过实现Comparator来新建一个比较器，然后通过这个比较器对类进行排序。

注：若一个类要实现Comparator接口：它一定要实现compare(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。
先是用于比较的自定义的JavaBean

public class Teacher{
    private String name;
    private int age;

    public Teacher(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;
    }

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

新建一个TeacherComparator，实现了Comparator。
与Comparable相似，o1在前面代表升序排列，o2在前面代表降序排列

import java.util.Comparator;

public class TeacherComparator implements Comparator<Teacher> {
    @Override
    public int compare(Teacher o1, Teacher o2) {
        return o2.getAge()-o1.getAge();
    }
}

最后，使用了Collections.sort方法对集合中的Teacher进行排序

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Teacher t1 = new Teacher("张三",18);
        Teacher t2 = new Teacher("李四",20);
        Teacher t3 = new Teacher("王五",19);
        Teacher t4 = new Teacher("赵六",17);
        List<Teacher> list = new ArrayList<>(4);
        list.add(t1);
        list.add(t2);
        list.add(t3);
        list.add(t4);

        System.out.println("排序前------------------");
        for (Teacher t:list) {
            System.out.println(t);
        }

        System.out.println("排序后------------------");
        // 通过这个方法可以传入Comparator进行排序
        Collections.sort(list, new TeacherComparator());
        for (Teacher t:list) {
            System.out.println(t);
        }
    }
}

三、Comparable和Comparator区别比较

1. Comparable是排序接口，若一个类实现了Comparable接口，就意味着“该类支持排序”。
2. Comparator是比较器，我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。

因此，Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。

两种方法各有优劣:

1. 用Comparable 简单， 只要实现Comparable 接口的对象直接就成为一个可以比较的对象，但是需要修改源代码。
2. 用Comparator 的好处是不需要修改源代码， 而是另外实现一个比较器， 当某个自定义的对象需要作比较的时候，把比较器和对象集合一起传递过去就可以比大小了， 并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑，使其可以匹配一些比较简单的对象。