边学边记——数据结构☞关于对象的比较（包括对equals()方法的重写，Comparable接口，Comparator接口的介绍）

目录

一、基本类型

二、引用类型——对象的比较

1. 关于同一性的比较

2. 关于相等性的比较

三、Comparable接口

1. 介绍

2. 实现

3. 什么叫做正确的compareTo方法的重写

四、实现Comparator接口（基于比较器比较）

1. 介绍

2. 实现

3. 使用场景

五、三种比较方式的对比

六、集合框架中PriorityQueue的比较方式

---

一、基本类型

基本类型的比较直接使用：

<，<=，==，!=，>，>=

二、引用类型——对象的比较

1. 关于同一性的比较

• 引用1 == 引用2 为true：引用1和引用2都指向同一个对象（特例：引用1 == 引用2 == null，说明两个引用都不指向任何对象）
• 引用1 != 引用2 为true：引用1和引用2没有指向同一个对象（特例：其中一个为null，说明一个指向对象，一个不指向对象）

注意：引用类型没有<，<=，>，>=的比较。

2. 关于相等性的比较

• 引用1.equals(引用2) == true：引用1指向的对象和引用2指向的对象是“相等”的（前提：对象的类正确的重写了equals方法）。

        覆写基类equals的方式虽然可以比较，但缺陷是：equal只能按照相等进行比较，不能按照大于、小于的方式进行比较。

关于equals方法的具体使用可以查看：toString方法和equals方法详解

那如果我们想要比较两个对象之间的大小关系（以引用格式体现），该如何实现呢？

Java语言帮我们指定了一个规范：Comparable接口。

三、Comparable接口

1. 介绍

Comparable官方文档

可以实现this和o这两个对象进行比较，源码实现具体如下：

public interface Comparable<E> {
    // 返回值:
    // < 0: 表示 this 指向的对象小于 o 指向的对象
    // == 0: 表示 this 指向的对象等于 o 指向的对象
    // > 0: 表示 this 指向的对象大于 o 指向的对象
    int compareTo(E o);
}

        对于用户自定义类型，如果要想按照大小与方式进行比较时：在定义类时，实现Comparble接口即可，然后在类中重写compareTo方法。

例：

int cmp = p1.compareTo(p2)

• this: p1
• o: p2

cmp < 0: p1小于p2

cmp == 0: p1和p2是相等的

cmp > 0: p1大于p2

比如说，String类的比较就实现了Comparable接口：

public class ComparableStringDemo {
    public static void main(String[] args) {
        String s = "hello";
        String t = "world";
        // h < w，所以 hello < 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 {
            // cmp > 0
            System.out.println(s + " 大于 " + t);
        }
    }
}

输出结果如下： 

此外，还有很多类也实现了Comparable接口，比如包装类，Date类等。

2. 实现

如果我们想比较一个自定义类Person的大小，该如何比较呢？

Person类如下：

(1). 首先使其实现Comparable接口

public class Person implements Comparable<Person>{
    private int height;

    private int weight;

    private int score;

    private int level;

    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 "javaDS.Person{" +
                "height=" + height +
                ", weight=" + weight +
                ", score=" + score +
                ", level=" + level +
                '}';
    }
}

(2). 重写Comparable接口中的compareTo方法

a. 按照等级排序：

@Override
    public int compareTo(Person o) {
        if (this.level > o.level) {
            // 认为 this 大于 o
            // 所以按照规范，应该返回任意一个大于 0 的整数
            return 1;
        } else if (this.level == o.level) {
            // 认为 this 等于 o
            return 0;
        } else {
            // this.level < o.level
            // 认为 this 小于 o
            // 返回负数
            return -1;
        }
    }

可以简写为：

@Override
    public int compareTo(Person o) {
        // 由于只需要返回整数、0、负数。所以上面的方法可以简写为：
        return this.level - o.level;
        // int - int 还是 int
        // this.level > o.level 时，相减的结果是正数
        // 相等时，结果是 0
        // 小于时，结果是 负数
    }

b. 如果等级相同，继续按分数排序

@Override
    public int compareTo(Person o) {
        int r = this.level - o.level;
        if (r != 0) {
            // this.level != o.level;
            return r;
        }

        // 说明 this.level == o.level;
        // 继续靠 score 确定大小
        return this.score - o.score;
    }

c. 按照综合成绩排序——通过权重分配

重写了equals方法，如果不重写equals，只是同一性比较，重写后才是相等性比较。

@Override
    public int compareTo(Person o) {
        // 求出 this 对象的综合得分
        // 身高：0.3 体重: 0.2 成绩：0.5 级别：0.4
        double t = this.height * 0.3 + this.weight * 0.2 + this.score * 0.5 + this.level * 0.4;
        double s = o.height * 0.3 + o.weight * 0.2 + o.score * 0.5 + o.level * 0.4;

        if (t > s) {
            return 1;
        } else if (t == s) {
            return 0;
        } else {
            return -1;
        }
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }

        if (!(obj instanceof Person)) {
            // obj 不是 Person
            return false;
        }

        Person o = (Person) obj;
        double t = this.height * 0.3 + this.weight * 0.2 + this.score * 0.5 + this.level * 0.4;
        double s = o.height * 0.3 + o.weight * 0.2 + o.score * 0.5 + o.level * 0.4;

        return t == s;
    }

整体代码参考：

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

    private int weight;

    private int score;

    private int level;

    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 "javaDS.Person{" +
                "height=" + height +
                ", weight=" + weight +
                ", score=" + score +
                ", level=" + 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 1;
//        } else if (this.level == o.level) {
//            // 认为 this 等于 o
//            return 0;
//        } else {
//            // this.level < o.level
//            // 认为 this 小于 o
//            // 返回负数
//            return -1;
//        }
//    }

//    @Override
//    public int compareTo(Person o) {
//        // 由于只需要返回整数、0、负数。所以上面的方法可以简写为：
//        return this.level - o.level;
//        // int - int 还是 int
//        // this.level > o.level 时，相减的结果是正数
//        // 相等时，结果是 0
//        // 小于时，结果是 负数
//    }

//    @Override
//    public int compareTo(Person o) {
//        int r = this.level - o.level;
//        if (r != 0) {
//            // this.level != o.level;
//            return r;
//        }
//
//        // 说明 this.level == o.level;
//        // 继续靠 score 确定大小
//        return this.score - o.score;
//    }
    
    @Override
    public int compareTo(Person o) {
        // 求出 this 对象的综合得分
        // 身高：0.3 体重: 0.2 成绩：0.5 级别：0.4
        double t = this.height * 0.3 + this.weight * 0.2 + this.score * 0.5 + this.level * 0.4;
        double s = o.height * 0.3 + o.weight * 0.2 + o.score * 0.5 + o.level * 0.4;

        if (t > s) {
            return 1;
        } else if (t == s) {
            return 0;
        } else {
            return -1;
        }
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }

        if (!(obj instanceof Person)) {
            // obj 不是 Person
            return false;
        }

        Person o = (Person) obj;
        double t = this.height * 0.3 + this.weight * 0.2 + this.score * 0.5 + this.level * 0.4;
        double s = o.height * 0.3 + o.weight * 0.2 + o.score * 0.5 + o.level * 0.4;

        return t == s;
    }
}

3. 什么叫做正确的compareTo方法的重写

• 遵守Comparable的规则：this小于o：负数；this等于o：负数；this大于o：正数。
• 遵循习惯的熟悉规律：自反性（a.compareTo(b) < 0 可以推出：b.compareTo(a) > 0和传递性（a.compareTo(b) < 0 && b.compareTo(c) < 0 可以推出：a.compareTo(c) < 0）
• 遵循和equals方法统一。

        但是光有Comparable接口，不足以比较所有的对象，因为不是所有的类都实现了Comparable接口，比如java.util.List接口，这种情况下，Java提供了另一种方式来解决这个问题——实现Comparator接口。

四、实现Comparator接口（基于比较器比较）

1. 介绍

Comparator官方文档

用户自定义比较器类，实现Comparator接口：

public interface Comparator<T> {
    // 返回值:
    // < 0: 表示 o1 指向的对象小于 o2 指向的对象
    // == 0: 表示 o1 指向的对象等于 o2 指向的对象
    // > 0: 表示 o1 指向的对象等于 o2 指向的对象
    int compare(T o1, T o2);
}

2. 实现

想要根据两个顺序表的长度大小比较他们的大小，长度长的大，长度短的小，重写compare方法：

static class ListComparator implements Comparator<List<Integer>> {
    // 准备自反、传递的特性
    @Override
    public int compare(List<Integer> o1, List<Integer> o2) {
        // 比较 o1 和 o2 的size
        return o1.size() - o2.size();
    }
}

整体代码如下：

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

public class ComparatorListDemo {
    static class ListComparator 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>> com = new ListComparator();

        int cmp = com.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);
    }
}

3. 使用场景

Comparator使用场景：

• 要比较的两个对象的类不具备自然顺序。
• 没有实现过Comparable接口的类。
• 要比较的两个对象的类具备自然顺序，但是自然顺序不符合我们预期。

五、三种比较方式的对比

覆写的方法	说明
Object.equals	因为所有类都是继承自 Object 的，所以直接覆写即可，不过只能比较相等与 否
Comparable.compareTo	需要手动实现接口，侵入性比较强，但一旦实现，每次用该类都有顺序，属于 内部顺序
Comparator.compare	需要实现一个比较器对象，对待比较类的侵入性弱，但对算法代码实现侵入性 强

六、集合框架中PriorityQueue的比较方式

        集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比大小，PriorityQueue采用了——Comparble和Comparator两种方式：

• Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接口，并覆写compareTo方法。
• 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现Comparator接口并覆写compare方法。

如有建议或想法，欢迎一起讨论学习~