Java 中 Comparable 和 Comparator

Comparable:逻辑含义：具有比较（compare）的能力（able）。

Comparable 接口仅仅只包括一个函数，它的定义如下

public interface Comparable<T> {
    public int compareTo(T o);
}

在接口里的抽象方法是 int compareTo(T o);

comparable分两个角度使用：

1):使用已经实现了 Comparable 的类的对象，如 String 类。

public static void main(String[] args) {
        String s = "hello";
        String t = "world";

        //要比较s 和 t 的大小
        int cmp = s.compareTo(t);   //按照字符进行依次比较
        if(cmp < 0){
            System.out.println("s 小于 t");
        }else if(cmp == 0){
            System.out.println("s 等于 t");
        }else{
            System.out.println("s 大于 t");
        }
    }

其结果显示：

s 小于 t

2）自己创建一个类实现 Comparable 接口

例如：创建一个Person 类并覆写 compareTo 方法。

若想比较两个person 的 level

// 1. 让类区实现 Comparable 接口
// Person(a) implements Comparable<Person(b)>
// 当前对象类型是 a：Person
// 可以和 b：Person 类型的对象进行比较
class Person implements Comparable<Person> {
    private final int height;
    private final int weight;
    private final int score;
    private final int level;

    /**
     * @param o the object to be compared.
     * @return 小于 0 的整数： this 小于 o
     * 等于 0 的整数： this 等于 o
     * 大于 0 的整数： this 大于 o
     */
    @Override
    public int compareTo(Person o) {
        if (this.level > o.level) {
            // 认为 this 大于 o
            // 所以按照规范，应该返回任意一个大于 0 的整数
//            return 199999;    // 只要大于 0 就行，具体是啥无所谓
            return 1;
        } else if (this.level == o.level) {
            // 认为 this 等于 o
            return 0;
        } else {
            // this.level < o.level
            // 认为 this 小于 o
            // 返回负数
            return -2000;
        }
    }

    public Person(int height, int weight, int score, int level) {
        this.height = height;
        this.weight = weight;
        this.score = score;
        this.level = level;
    }

    @Override
    public String toString() {
        return "Person{" +
                "height=" + height +
                ", weight=" + weight +
                ", score=" + score +
                ", level=" + level +
                '}';
    }
    public static void main(String[] args) {
        Person s = new Person(1, 2, 3, 4); // level = 4
        Person t = new Person(10, 11, 12, 13);  // level = 13

        int cmp = s.compareTo(t);
        if (cmp < 0) {
            System.out.println(s + " 小于 " + t); // 这个是我们的预期
        } else if (cmp == 0) {
            System.out.println(s + " 等于 " + t);
        } else {
            // cmp > 0
            System.out.println(s + " 大于 " + t);
        }
    }

其输出结果为：

Person{height=1, weight=2, score=3, level=4} 小于 Person{height=10, weight=11, score=12, level=13}

---

Comparator：逻辑定义：比较（compare）xx 的东西（or）。

光有Compareable接口，不足以比较所有的对象，因为不是所有的类都实现了Compareable接口。

因此，这种情况下，Java提供了另一种方式来解决这个问题：

java.util.comparator的接口

Comparato的定义如下:

public interface Comparator<T>{
    int compare(T o1, T o2);
}

使用Comparator的条件是：

1）要比较两个对象的类不具备自然顺序并且没有实现过Compareable的接口

2）要比较两个对象的类具备自然顺序，但他自然顺序不符合我们预期

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

public class Demo2 {
    static class 用于比较List的比较器 implements Comparator<List<Integer>> {
        @Override
        public int compare(List<Integer> o1, List<Integer> o2) {
            // 比较 o1 和 o2 的size
            return o1.size() - o2.size();
        }
    }

    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();
        input1(list1);

        List<Integer> list2 = new ArrayList<>();
        input2(list2);

        Comparator<List<Integer>> 天平 = new 用于比较List的比较器();

        int cmp = 天平.compare(list1, list2);
        if (cmp < 0) {
            System.out.println("list1 小于 list2");
        } else if (cmp == 0) {

            System.out.println("list1 等于 list2");
        } else {

            System.out.println("list1 大于 list2");
        }

        // 比较 list1 和 list2 的大小
        // 1）检查 List 类是不是 Comparable 的实现类 或者 List 接口是不是 Comparable 接口的子接口
        // List 或者 ArrayList 都和 Comparable 之间没有关系
    }

    private static void input1(List<Integer> list) {
        list.add(1);
        list.add(2);
        list.add(3);
    }
    private static void input2(List<Integer> list) {
        list.add(3);
        list.add(4);
    }

}

其输出结果如下：

list1 大于 list2

总的来说， comparable 为内部比较器，comparator 为外部比较器。

---