java中Comparable与Comparator的比较

1.Comparable接口

Comparable又称排序接口，即如果有一个类实现了该接口，那么该类可以根据某种规则（比如类中属性）来进行排序，所以我们可以对实现了Comparable接口的类的对象的List集合（或数组array[ ]），通过Collections.sort(list)来对list中该类对象进行排序（数组排序可用Arrays.sort(array)）。故Comparable接口是内部比较器接口。

对于某些实现Comparable接口的类的对象，可以作为有序映射集合（比如TreeMap）中的键，也可以作为有序集合TreeSet中的元素，而不需要实现Comparable接口。

在Comparable接口中仅定义了一个方法：public int compareTo(T o);T类型即是你自己定义的实现了该接口的类。你需要在实现该接口的类中自定义比较规则。我们通过obj.compareTo(o)来比较两者大小，返回值为负数，则obj 次序在o之前。返回0则两者次数相同。返回正数，则obj的次数在o之后。

2.Comparator接口

Comparator接口又称为比较器接口。如果我们想对某个类进行排序，但是该类没有实现Comparable接口（可以理解为，我们原先没有想对该类进行排序，后来想排序时不想改动原有代码），则我们需要自定义该类的比较器类，这个比较器类只需要实现了Comparator接口即可。故Comparator接口是外部比较器接口。我们可以理解为，不改动需要比较的类，而在外部自定义该类的比较器，通过比较器来对该类进行排序。Comparator接口中有两个需要实现的方法：int compare(T o1, T o2) 与 boolean equals(Object obj)，但是equals(Object obj)方法是Object类的方法，任何类都是Object类子类，都默认实现了equals()，所以我们只需要实现 int compare(T o1, T o2)即可。我们通过compare(T o1, T o2)来比较两者大小，返回值为负数，则o1次序在o2之前。返回0则两者次数相同。返回正数，则o1的次数在o2之后。

3.通过代码来进行分析：

3.1内部实现Comparable接口：

1)定义需要比较的类Person：

package com.java.compare;

public class Person implements Comparable<Person> {

    private int age;
    private String name;

    public Person() {
        
    }

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }

    @Override
    public int compareTo(Person p) {
        //此处是通过age的大小来排序
        return this.age - p.getAge();
        //此处是通过name的字符序列来确定Person对象的序列
//        return this.name.compareTo(p.getName());
    }

}
2）测试类

package com.java.compare;

import java.util.Arrays;

public class PersonTest {

    public static void main(String[] args) {
        Person[] ps = {new Person(12, "Per"), new Person(11, "AA")};
        Arrays.sort(ps);
        System.out.println(Arrays.toString(ps));
    }
}
输出排序后的数组：

3.2外部自定义比较器类

1）定义需要排序的类Student（注意：没有实现Comparable接口）

package com.java.compare;

public class Student {

    private int age;
    private String name;

    public Student() {
        super();
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int 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 + "]";
    }
}

2）自定义外部比较器类

package com.java.compare;

import java.util.Comparator;

public class StudentComparator implements Comparator<Student> {

    @Override
    public int compare(Student s1, Student s2) {
        return s1.getAge() - s2.getAge();
//        return s1.getName().compareTo(s2.getName());
    }
}

3）测试类
package com.java.compare;

import java.util.Arrays;

public class StudentTest {

    public static void main(String[] args) {
        Student s1 = new Student(12, "BAA");
        Student s2 = new Student(1, "ba");
        StudentComparator comp = new StudentComparator();
        Student[] list = {s1, s2};
        Arrays.sort(list, comp);
        System.out.println(Arrays.toString(list));
    }
}

运行结果：

4.总结：

Comparable是内部比较器，我们需要让需要实现排序的类来实现该接口。我们通过重写 public int compareTo(T o)来确定排序的规则。而Comparator是外部比较器。我们不需要修改要排序的类，而是通过重新定义一个外部比较器类，该类实现了Comparator接口。我们通过重写public int compare(T s1, T s2) 来内部比较两个对象的次序。