【javaSE】中基本类型和引用类型对象的比较及PriorityQueue中的比较方法

红太狼 2024-03-29 16:14 77阅读 0赞

写博客是为了提升自己，也是为了展现自己的学习成果，坚持!坚持!坚持！未来是什么样的，闯一闯就知道啦。喜欢就留个关注吧！！!

![ec75740744a14930be2e650a9a93821d.png][]

**目录**

一、java对象的比较

1.1java中基本类型的比较

1.2引用对象的比较

1.3引用对象基于Comparble接口类的比较

1.4引用对象基于比较器的比较

1.5三种方式的对比

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

2.1PriorityQueue中的比较方式

--------------------

## 一、java对象的比较 ##

### 1.1java中基本类型的比较 ###

> 在Java中，基本类型的对象可以直接比较大小。例如：int，char，boolean，float，double...

public class Test {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            System.out.println(a > b);
            System.out.println(a < b);
            System.out.println(a == b);
            char c1 = 'A';
            char c2 = 'B';
            System.out.println(c1 > c2);
            System.out.println(c1 < c2);
            System.out.println(c1 == c2);
            boolean b1 = true;
            boolean b2 = false;
            System.out.println(b1 == b2);
            System.out.println(b1 != b2);
        }
    }

![b6cb9e98938a4b019685e74955605c88.png][]

### 1.2引用对象的比较 ###

> 对引用对象进行比较，需要重写某些接口的方法，下面我来演示一下

class Card {
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
    this.rank = rank;
    this.suit = suit;
    }
    }
    public class TestPriorityQueue {
    public static void main(String[] args) {
    Card c1 = new Card(1, "♠");
    Card c2 = new Card(2, "♠");
    Card c3 = c1;
    //System.out.println(c1 > c2); // 编译报错
    System.out.println(c1 == c2); // 编译成功 ----> 打印false，因为c1和c2指向的是不同对象
    //System.out.println(c1 < c2); // 编译报错
    System.out.println(c1 == c3); // 编译成功 ----> 打印true，因为c1和c3指向的是同一个对象
    }
    }

![02a0276d076646c4a74e30a5cbc04825.png][]

> c1、c2和c3分别是Card类型的引用变量，上述代码在比较编译时：  
> c1 > c2 编译失败  
> c1== c2 编译成功  
> c1 < c2 编译失败
> 
> 从编译结果可以看出，Java中引用类型的变量不能直接按照 > 或者 < 方式进行比较。 那为什么==可以比较？

> 因为：对于用户实现自定义类型，都默认继承自Object类，而Object类中提供了equal方法，而==默认情况下调用的就是equal方法，但是该方法的比较规则是：没有比较引用变量引用对象的内容，而是直接比较引用变量的地址，但有些情况下该种比较就不符合题意。

equals源码：

// Object中equal的实现，可以看到：直接比较的是两个引用变量的地址
    public boolean equals(Object obj) {
    return (this == obj);
    }

> 那么我们想要去比较对象，可以去重写Object类的equals方法

@Override
    public boolean equals(Object o) {
    // 自己和自己比较
    if (this == o) {
    return true;
    }
    // o如果是null对象，或者o不是Card的子类
    if (o == null || !(o instanceof Card)) {
    return false;
    } 
    // 注意基本类型可以直接比较，但引用类型最好调用其equal方法
    Card c = (Card)o;
    return rank == c.rank
    && suit.equals(c.suit);
     }
    }

> 注意： 一般覆写 equals 的套路就是上面演示的  
> 1. 如果指向同一个对象，返回 true  
> 2. 如果传入的为 null，返回 false  
> 3. 如果传入的对象类型不是 Card，返回 false  
> 4. 按照类的实现目标完成比较，例如这里只要花色和数值一样，就认为是相同的牌  
> 5. 注意下调用其他引用类型的比较也需要 equals，例如这里的 suit 的比较  
> 覆写基类equal的方式虽然可以比较，但缺陷是：equal只能按照相等进行比较，不能按照大于、小于的方式进行比较。

### 1.3引用对象基于Comparble接口类的比较 ###

> Comparble是JDK提供的泛型的比较接口类，源码实现具体如下：

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

![d251296b91944e59bb23bc9d4d54156e.png][]

![d1387adbee7c4551a99977971b19d0c3.png][]

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

class Student implements Comparable<Student>{
        public int age;
        public String name;
    
        public Student(String name,int age) {
            this.name = name;
            this.age = age;
    
        }
    @Override
        public int compareTo(Student o) {
            return this.age - o.age;
        }
    }
    public static void main(String[] args) {
      Student student1 = new Student("zhangsan",10);
      Student student2 = new Student("zhangsan",20);
      System.out.println(student1 == student2);
      System.out.println(student1.equals(student2));
      System.out.prinln(student1.compareTo(student2));
    }

![fbc3f822d59c498785aeb74ae4e081e8.png][]

> Compareble是java.lang中的接口类，可以直接使用。

### 1.4引用对象基于比较器的比较 ###

> 对于引用对象，我们还可以用比较器进行比较：用户自定义比较器类，实现Comparator接口

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

> 注意：区分Comparable和Comparator。

import java.util.Comparator;
    import java.util.Objects;
    
    class Student implements {
        public int age;
        public String name;
    
        public Student(String name,int age) {
            this.name = name;
            this.age = age;
    
        }
    
    class NameComparator implements Comparator<Student>{
    
        @Override
        public int compare(Student o1, Student o2) {
        if (o1 == o2) {
        return 0;
        } 
        if(o1 == null) {
        return -1;
        }
        if(o2 == null) {
        return -1;
        }
            return o1.name.compareTo(o2.name);
        }
    }
    
    class AgeComparator implements Comparator<Student>{
    
        @Override
        public int compare(Student o1, Student o2) {
    
        if (o1 == o2) {
        return 0;
        } 
        if(o1 == null) {
        return -1;
        }
        if(o2 == null) {
        return -1;
        }
    
            return o2.age - o1.age;
        }
    }
    
    
    
    public static void main(String[] args) {
            Student student1 = new Student("zhangsan",10);
            Student student2 = new Student("zhangsan",20);
            // 定义比较器对象
            NameComparator nameComparator = new NameComparator();
            int ret = nameComparator.compare(student1,student2);
            System.out.println(ret);
            // 使用比较器对象进行比较
            AgeComparator ageComparator = new AgeComparator();
            int ret2 = ageComparator.compare(student1,student2);
            System.out.println(ret2);
    }

![ae1d3bfebc764a5b9eed390073bb6686.png][]

> 注意：Comparator是java.util 包中的泛型接口类，使用时必须导入对应的包.

### 1.5三种方式的对比 ###

<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的比较方式 ##

### 2.1PriorityQueue中的比较方式 ###

> 集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比大小，PriorityQueue采用了：  
> Comparble和Comparator两种方式。  
> 1. Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接口，并覆写compareTo方法  
> 2. 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现Comparator接口并覆写compare方法。``

### ![c16a1ebfad614396b4f4ea234a08491d.png][] ###

![772d549789ba46379ab636fa73e32d73.png][]

![26b2d488a26142e79364c8440199b742.png][]

![820581da03d242949462bba8721618be.png][]

![b32afc7e41cd48739bf14b1f7a925178.png][]

>  向上调整：  
> 如果用户没有提供比较器对象，采用Comparable进行比较  
> 否则使用用户提供的比较器对象进行比较

### ![1f8f0e9bdb004867b46d141d279a4cbb.png][] ###

>  使用Comparable举个例子：

class Student implements Comparable<Student>{
        public int age;
        public String name;
    
        public Student(String name,int age) {
            this.name = name;
            this.age = age;
    
        }
    
    class AgeComparator implements Comparator<Student>{
    
        @Override
        public int compare(Student o1, Student o2) {
            return o2.age - o1.age;
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            AgeComparator ageComparator = new AgeComparator();
            Queue<Student> priorityQueue2 = new PriorityQueue<>(ageComparator);
            priorityQueue2.offer(new Student("zhangsan",27));
            priorityQueue2.offer(new Student("lisi",15));
            priorityQueue2.poll();
    }
    }

### ![838b6de72a1a4768aaa20c69bb73c598.png][] ###

### ![9fe124694a8e446f9a85275b31879c62.png][] ###

> 在PriorityQueue中按降序进行排序。

[ec75740744a14930be2e650a9a93821d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/1a7be752036b4999a2b622fe4710565d.png
[b6cb9e98938a4b019685e74955605c88.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/080353459fb24483ae6e3e6eddbdd853.png
[02a0276d076646c4a74e30a5cbc04825.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/5e10b088a73d40428eeed5e5d083b598.png
[d251296b91944e59bb23bc9d4d54156e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/81b1f2896c5a4e3096bb01fcc7c82d40.png
[d1387adbee7c4551a99977971b19d0c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/ea90367d605444b18e79150edd4e6add.png
[fbc3f822d59c498785aeb74ae4e081e8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/34285f7a17ba458f8c5ec42e0fbb2c83.png
[ae1d3bfebc764a5b9eed390073bb6686.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/f01e4c3ade144f208796f236548d10f8.png
[c16a1ebfad614396b4f4ea234a08491d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/cbbbd430220c41008bcc625bc22bcae4.png
[772d549789ba46379ab636fa73e32d73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/11656fd2264c4308a0fbe97771bca7e7.png
[26b2d488a26142e79364c8440199b742.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/6ae2dba139ea44f5a94f2372674a795d.png
[820581da03d242949462bba8721618be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/dda701dd785a4051804ba5d1dc0ea2af.png
[b32afc7e41cd48739bf14b1f7a925178.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/a2711d32872e4fe8938eb88856f09a3c.png
[1f8f0e9bdb004867b46d141d279a4cbb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/568aef15dffe40369c8895e718ba536d.png
[838b6de72a1a4768aaa20c69bb73c598.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/d37554280bce451fa5f9bf3a6ae16e4b.png
[9fe124694a8e446f9a85275b31879c62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/a3865f2e02364da88dc90509338036b3.png