Comparable与Comparator用法详解

简介：

Comparable接口出自java.lang包，它有一个compareTo(Object obj)方法用来比较或排序
Comparator接口出自java.util包，它有一个compare(Object obj1、Object obj2)方法用来排序。

当我们需要对集合进行自定义排序或对象之间进行比较时，就需要重写compareTo()或者compare()方法。

---

Comparable：

Comparable是一个对象支持自比较所需要实现的接口，如String、Integer自己就实现了Comparable接口，我们可以直接用他们的CompareTo()方法来比较，或者直接对List<String>或List<Integer>集合进行排序。
例如：

String s1 = "abc";
String s2 = "aba";
System.out.println(s1.compareTo(s2)); // 2

List<String> list = new ArrayList<>();
list.add("abc");
list.add("ab");
list.add("dde");
Collections.sort(list);

for (String s : list) {
    System.out.println(s);
}

而我们自定义的类如果想进行比较，或者放入list中进行排序，则需要实现Comparable接口的compareTo方法，这样才支持比较或者排序。否则我们直接调用Collections.sort(list)会出现编译错误的。比如我们有一个Person类，两个属性姓名和年龄，想让List<Person>通过年龄来排序：

public class Person implements Comparable<Person>{

    private String name;
    private int age;

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

    public String getName() {
        return this.name;
    }

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

    public int getAge() {
        return this.age;
    }

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

    @Override
    public int compareTo(Person o) {

        if(this.age == o.getAge() && this.name == o.getName()){
            return 0;
        }else if(this.age > o.getAge()){
            return 1;
        }else{
            return -1;
        }

    }

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

import JavaTest.compare.Person;
import org.junit.Test;
import java.util.*;

public class Test1 {
    @Test
    public void testComparable() {
        List<Person> list = new ArrayList<>();
        Person person1 = new Person("张三",22);
        Person person2 = new Person("李四",29);
        Person person3 = new Person("王五",42);
        list.add(person1);
        list.add(person2);
        list.add(person3);
        // 实现comparable接口就会自动调用compareTo进行排序
        Collections.sort(list);
        for (Person p: list) {
            System.out.println(p);
        }
        //比较
        System.out.println(person1.compareTo(person2));

    }
}

---

Comparator：

Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足要求时(比如二维数组排序，后面会讲到)，可写一个比较器来完成两个对象之间大小的比较，或者集合排序。
例如：一个User类，同样有年龄和姓名属性，我们想对List排序，但User类没有实现Comparable接口，假定User类我们不能修改，此时我们可以用Comparator来实现。

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

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

    public String getName() {
        return this.name;
    }

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

    public int getAge() {
        return this.age;
    }

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

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

@Test
public void testComparator() {
    List<User> list = new ArrayList<>();
    User user1 = new User("张三",22);
    User user2 = new User("李四",29);
    User user3 = new User("王五",42);
    list.add(user1);
    list.add(user2);
    list.add(user3);
    Collections.sort(list, new Comparator<User>() {
        @Override
        public int compare(User o1, User o2) {
            if(o1.getAge() == o2.getAge() && o1.getName() == o2.getName()){
                return 0;
            }else if(o1.getAge() > o2.getAge()){
                return 1;
            }else{
                return -1;
            }
        }
    });

    for (User u: list) {
        System.out.println(u);
    }

}

我们这里通过匿名类的形式new Comparator<User>() 来实现list集合的排序，当然我们也可以再定义一个UserComparator类来实现Comparator接口，然后通过 UserComparator uc = new UserComparator(); Collections.sort(list, uc); 来实现。

由这两个例子看出Comparable是类的内部实现比较或排序功能，Comparator是外部实现的。

二维数组排序：
另外举个例子，二维数组排序，按照某一列列大小对数组进行排序。二维数组的排序直接调用Arrays.sort(); 虽然不会出现编译错误，但运行时会出现以下错误提示：

说明不可以这样用，而我们又想对它排序，就可以使用Comparator来外部实现排序了，这里举一个按照第二列数字大小进行排序的例子：

public class ArrayCompare {
    public static void main(String[] args) {
    
        int[][] arr = new int[4][2];
        System.out.println("产生的二维数组arr为：");
        for (int i = 0; i < 4; i++) {
            arr[i][0] = (int)(Math.random()*10 + 1);
            arr[i][1] = (int)(Math.random()*10 + 2);
            System.out.println(Arrays.toString(arr[i]));
        }

        //arr2拷贝一份arr的值，这里没什么意义，就简单使用一下clone
        int[][] arr2 = new int[4][2];
        arr2 = arr.clone();


        //arr以第二列值大小排序
        Arrays.sort(arr2, new Comparator<int[]>() {
            @Override
            public int compare(int[] t0, int[] t1) { // t0与t1类似于两个对象进行比较，这里表示两个一维数组，即二维数组的两行
                if(t0[1] == t1[1]){
                    return t0[0]-t1[0]; //第二列中的值相同时，再比较第一列的大小，如果不需要也可以直接return 0
                }
                return t0[1] - t1[1];
            }
        });

        System.out.println("arr自定义排序为：");
        showArray(arr2);
    }

    public static void showArray(int[][] arr){
        for (int[] row : arr) {
            System.out.println(Arrays.toString(row));
        }
    }
}

---