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

蔚落 2023-09-30 23:57 1阅读 0赞

**目录**

一、基本类型

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

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方法详解][toString_equals]

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

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

## **三、Comparable接口** ##

### **1. 介绍** ###

[Comparable官方文档][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);
            }
        }
    }

输出结果如下：

![8cbfd9b457a54dcaa7644220d5dd8b84.png][]

此外，还有很多类也实现了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]

用户自定义比较器类，实现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接口的类。
>  *  要比较的两个对象的类具备自然顺序，但是自然顺序不符合我们预期。

## 五、三种比较方式的对比 ##

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

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

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

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

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

[toString_equals]: https://blog.csdn.net/lil_ghost_/article/details/126960166?spm=1001.2014.3001.5501
[Comparable]: https://docs.oracle.com/javase/7/docs/api/java/lang/Comparable.html
[8cbfd9b457a54dcaa7644220d5dd8b84.png]: https://img-blog.csdnimg.cn/8cbfd9b457a54dcaa7644220d5dd8b84.png
[Comparator]: https://docs.oracle.com/javase/7/docs/api/java/util/Comparator.html