java对象的比较

男娘i 2024-04-28 07:38 142阅读 0赞

java对象的比较

  • ?1. 问题提出?
  • ?2. 元素的比较?
    • 2.1 基本类型的比较
    • 2.2 对象的比较
  • ? 3. 对象的比较 ?
    • 3.1 覆写基类的equal
    • 3.2 基于`Comparble`接口类的比较
    • 3.3 基于比较器比较
    • 3.4 三种方式对比
  • ?4. 集合框架中`PriorityQueue`的比较方式?
  • ?5. 模拟实现`PriorityQueue`?

大家好，我是晓星航。今天为大家带来的是 java对象的比较 相关内容的讲解！?

?1. 问题提出?

上节课我们讲了优先级队列，优先级队列在插入元素时有个要求：插入的元素不能是null或者元素之间必须要能够进行比较，为了简单起见，我们只是插入了Integer类型，那优先级队列中能否插入自定义类型对象呢？

202304211044850.png

  1. class Card {
  3.     public int rank; // 数值
  4.     public String suit; // 花色
  5.     public Card(int rank, String suit) {
  7.         this.rank = rank;
  8.         this.suit = suit;
  9.     }
  10. }
  11. public class TestPriorityQueue {
  13.     public static void TestPriorityQueue()
  14.     {
  16.         PriorityQueue<Card> p = new PriorityQueue<>();
  17.         p.offer(new Card(1, "♠"));
  18.         p.offer(new Card(2, "♠"));
  19.     }
  20.     public static void main(String[] args) {
  22.         TestPriorityQueue();
  23.     }
  24. }

优先级队列底层使用堆，而向堆中插入元素时，为了满足堆的性质，必须要进行元素的比较，而此时Card是没有办法直接进行比较的，因此抛出异常。

202304211045594.png 202304211052161.png

?2. 元素的比较?

2.1 基本类型的比较

在Java中，基本类型的对象可以直接比较大小。

  1. public class TestCompare {
  3.     public static void main(String[] args) {
  5.         int a = 10;
  6.         int b = 20;
  7.         System.out.println(a > b);
  8.         System.out.println(a < b);
  9.         System.out.println(a == b);
  10.         char c1 = 'A';
  11.         char c2 = 'B';
  12.         System.out.println(c1 > c2);
  13.         System.out.println(c1 < c2);
  14.         System.out.println(c1 == c2);
  15.         boolean b1 = true;
  16.         boolean b2 = false;
  17.         System.out.println(b1 == b2);
  18.         System.out.println(b1 != b2);
  19.     }
  20. }

2.2 对象的比较

  1. class Card {
  3.     public int rank; // 数值
  4.     public String suit; // 花色
  5.     public Card(int rank, String suit) {
  7.         this.rank = rank;
  8.         this.suit = suit;
  9.     }
  10. }
  11. public class TestPriorityQueue {
  13.     public static void main(String[] args) {
  14.     Card c1 = new Card(1, "♠");
  15.         Card c2 = new Card(2, "♠");
  16.         Card c3 = c1;
  17.       //System.out.println(c1 > c2); // 编译报错
  18.         System.out.println(c1 == c2); 
  19.         // 编译成功 ----> 打印false，因为c1和c2指向的是不同对象
  20.       //System.out.println(c1 < c2); // 编译报错
  21.         System.out.println(c1 == c3); 
  22.         // 编译成功 ----> 打印true，因为c1和c3指向的是同一个对象
  23.     }
  24. }

c1、c2和c3分别是Card类型的引用变量，上述代码在比较编译时：

c1 > c2 编译失败

c1== c2 编译成功

c1 < c2 编译失败

从编译结果可以看出，Java中引用类型的变量不能直接按照 > 或者 < 方式进行比较。 那为什么==可以比较？

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

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

? 3. 对象的比较 ?

有些情况下，需要比较的是对象中的内容，比如：向优先级队列中插入某个对象时，需要对按照对象中内容来调整堆，那该如何处理呢？

3.1 覆写基类的equal

  1. public class Card {
  3.     public int rank; // 数值
  4.     public String suit; // 花色
  5.     public Card(int rank, String suit) {
  7.         this.rank = rank;
  8.         this.suit = suit;
  9.     }
  10.     @Override
  11.     public boolean equals(Object o) {
  13.         // 自己和自己比较
  14.         if (this == o) {
  16.             return true;
  17.         }
  18.         // o如果是null对象，或者o不是Card的子类
  19.         if (o == null || !(o instanceof Card)) {
  21.             return false;
  22.         }
  23.         // 注意基本类型可以直接比较，但引用类型最好调用其equal方法
  24.         Card c = (Card)o;
  25.         return rank == c.rank
  26.                 && suit.equals(c.suit);
  27.     }
  28. }

注意： 一般覆写 equals 的套路就是上面演示的

  1. 如果指向同一个对象，返回 true
  2. 如果传入的为 null，返回 false
  3. 如果传入的对象类型不是 Card，返回 false
  4. 按照类的实现目标完成比较，例如这里只要花色和数值一样，就认为是相同的牌
  5. 注意下调用其他引用类型的比较也需要 equals，例如这里的 suit 的比较

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

3.2 基于Comparble接口类的比较

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

  1. public interface Comparable<E> {
  3.     // 返回值:
  4. // < 0: 表示 this 指向的对象小于 o 指向的对象
  5. // == 0: 表示 this 指向的对象等于 o 指向的对象
  6. // > 0: 表示 this 指向的对象等于 o 指向的对象
  7.     int compareTo(E o);
  8. }

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

  1. public class Card implements Comparable<Card> {
  3.     public int rank; // 数值
  4.     public String suit; // 花色
  5.     public Card(int rank, String suit) {
  7.         this.rank = rank;
  8.         this.suit = suit;
  9.     }
  10.     // 根据数值比较，不管花色
  11. // 这里我们认为 null 是最小的
  12.     @Override
  13.     public int compareTo(Card o) {
  15.         if (o == null) {
  17.             return 1;
  18.         }
  19.         return rank - o.rank;
  20.     }
  21.     public static void main(String[] args){
  23.         Card p = new Card(1, "♠");
  24.         Card q = new Card(2, "♠");
  25.         Card o = new Card(1, "♠");
  26.         System.out.println(p.compareTo(o)); // == 0，表示牌相等
  27.         System.out.println(p.compareTo(q));// < 0，表示 p 比较小
  28.         System.out.println(q.compareTo(p));// > 0，表示 q 比较大
  29.     }
  30. }

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

3.3 基于比较器比较

按照比较器方式进行比较，具体步骤如下：

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

    public interface Comparator {

    1. // 返回值:

    // < 0: 表示 o1 指向的对象小于 o2 指向的对象
    // == 0: 表示 o1 指向的对象等于 o2 指向的对象
    // > 0: 表示 o1 指向的对象等于 o2 指向的对象

    1. int compare(T o1, T o2);

    }

注意：区分Comparable和Comparator。

  • 覆写Comparator中的compare方法

    import java.util.Comparator;
    class Card {

    1. public int rank; // 数值
    2. public String suit; // 花色
    3. public Card(int rank, String suit) {
    5.     this.rank = rank;
    6.     this.suit = suit;
    7. }

    }
    class CardComparator implements Comparator {

    // 根据数值比较，不管花色
    // 这里我们认为 null 是最小的
    @Override
    public int compare(Card o1, Card o2) {

    1. if (o1 == o2) {
    3.     return 0;
    4. }
    5. if (o1 == null) {
    7.     return -1;
    8. }
    9. if (o2 == null) {
    11.     return 1;
    12. }
    13. return o1.rank - o2.rank;

    }

    1. public static void main(String[] args){
    3.     Card p = new Card(1, "♠");
    4.     Card q = new Card(2, "♠");
    5.     Card o = new Card(1, "♠");

    // 定义比较器对象

    1.     CardComparator cmptor = new CardComparator();

    // 使用比较器对象进行比较

    1.     System.out.println(cmptor.compare(p, o)); // == 0，表示牌相等
    2.     System.out.println(cmptor.compare(p, q)); // < 0，表示 p 比较小
    3.     System.out.println(cmptor.compare(q, p)); // > 0，表示 q 比较大
    4. }

    }

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

3.4 三种方式对比

202304211047353.png 202304211052859.png

?4. 集合框架中PriorityQueue的比较方式?

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

  1. Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接口，并覆写compareTo方法

  2. 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现Comparator接口并覆写compare方法。

    // JDK中PriorityQueue的实现：
    public class PriorityQueue extends AbstractQueue

    1.     implements java.io.Serializable {
    3. // ...

    // 默认容量

    1. private static final int DEFAULT_INITIAL_CAPACITY = 11;
    2. // 内部定义的比较器对象，用来接收用户实例化PriorityQueue对象时提供的比较器对象
    3. private final Comparator<? super E> comparator;
    4. // 用户如果没有提供比较器对象，使用默认的内部比较，将comparator置为null
    5. public PriorityQueue() {
    7.     this(DEFAULT_INITIAL_CAPACITY, null);
    8. }
    9. // 如果用户提供了比较器，采用用户提供的比较器进行比较
    10. public PriorityQueue(int initialCapacity, Comparator<? super E> comparator) {

    // Note: This restriction of at least one is not actually needed,
    // but continues for 1.5 compatibility

    1.     if (initialCapacity < 1)
    2.         throw new IllegalArgumentException();
    3.     this.queue = new Object[initialCapacity];
    4.     this.comparator = comparator;
    5. }
    6. // ...

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

    1. private void siftUp(int k, E x) {
    3.     if (comparator != null)
    4.         siftUpUsingComparator(k, x);
    5.     else
    6.         siftUpComparable(k, x);
    7. }
    8. // 使用Comparable
    9. @SuppressWarnings("unchecked")
    10. private void siftUpComparable(int k, E x) {
    12.     Comparable<? super E> key = (Comparable<? super E>) x;
    13.     while (k > 0) {
    15.         int parent = (k - 1) >>> 1;
    16.         Object e = queue[parent];
    17.         if (key.compareTo((E) e) >= 0)
    18.             break;
    19.         queue[k] = e;
    20.         k = parent;
    21.     }
    22.     queue[k] = key;
    23. }
    24. // 使用用户提供的比较器对象进行比较
    25. @SuppressWarnings("unchecked")
    26. private void siftUpUsingComparator(int k, E x) {
    28.     while (k > 0) {
    30.         int parent = (k - 1) >>> 1;
    31.         Object e = queue[parent];
    32.         if (comparator.compare(x, (E) e) >= 0)
    33.             break;
    34.         queue[k] = e;
    35.         k = parent;
    36.     }
    37.     queue[k] = x;
    38. }

    }

?5. 模拟实现PriorityQueue?

  1. class LessIntComp implements Comparator<Integer>{
  3.     @Override
  4.     public int compare(Integer o1, Integer o2) {
  6.         return o1 - o2;
  7.     }
  8. }
  9. class GreaterIntComp implements Comparator<Integer>{
  11.     @Override
  12.     public int compare(Integer o1, Integer o2) {
  14.         return o2 - o1;
  15.     }
  16. }
  17. // 假设：创建的是小堆----泛型实现
  18. public class MyPriorityQueue<E> {
  20.     private Object[] hp;
  21.     private int size = 0;
  22.     private Comparator<? super E> comparator = null;
  23.     // java8中：优先级队列的默认容量是11
  24.     public MyPriorityQueue(Comparator<? super E> com) {
  26.         hp = new Object[11];
  27.         size = 0;
  28.         comparator = com;
  29.     }
  30.     public MyPriorityQueue() {
  32.         hp = new Object[11];
  33.         size = 0;
  34.         comparator = null;
  35.     }
  36.     // 按照指定容量设置大小
  37.     public MyPriorityQueue(int capacity) {
  39.         capacity = capacity < 1 ? 11 : capacity;
  40.         hp = new Object[capacity];
  41.         size = 0;
  42.     }
  43.     // 注意：没有此接口，给学生强调清楚
  44.     // java8中：可以将一个集合中的元素直接放到优先级队列中
  45.     public MyPriorityQueue(E[] array){
  47.         // 将数组中的元素放到优先级队列底层的容器中
  48.         hp = Arrays.copyOf(array, array.length);
  49.         size = hp.length;
  50.         // 对hp中的元素进行调整
  51.         // 找到倒数第一个非叶子节点
  52.         for(int root = ((size-2)>>1); root >= 0; root--){
  54.             shiftDown(root);
  55.         }
  56.     }
  57.     // 插入元素
  58.     public void offer(E val){
  60.         // 先检测是否需要扩容
  61.         grow();
  62.         // 将元素放在最后位置，然后向上调整
  63.         hp[size] = val;
  64.         size++;
  65.         shiftUp(size-1);
  66.     }
  67.     // 删除元素: 删除堆顶元素
  68.     public void poll(){
  70.         if(isEmpty()){
  72.             return;
  73.         }
  74.         // 将堆顶元素与堆中最后一个元素进行交换
  75.         swap((E[])hp, 0, size-1);
  76.         // 删除最后一个元素
  77.         size--;
  78.         // 将堆顶元素向下调整
  79.         shiftDown(0);
  80.     }
  81.     public int size(){
  83.         return size;
  84.     }
  85.     public E peek(){
  87.         return (E)hp[0];
  88.     }
  89.     boolean isEmpty(){
  91.         return 0 == size;
  92.     }
  93.     // 向下调整
  94.     private void shiftDown(int parent){
  96.         if(null == comparator){
  98.             shiftDownWithcompareTo(parent);
  99.         }
  100.         else{
  102.             shiftDownWithComparetor(parent);
  103.         }
  104.     }
  105.     // 使用比较器比较
  106.     private void shiftDownWithComparetor(int parent){
  108.         // child作用：标记最小的孩子
  109.         // 因为堆是一个完全二叉树，而完全二叉树可能有左没有有
  110.         // 因此：默认情况下，让child标记左孩子
  111.         int child = parent * 2 + 1;
  112.         // while循环条件可以一直保证parent左孩子存在，但是不能保证parent的右孩子存在
  113.         while(child < size)
  114.         {
  116.             // 找parent的两个孩子中最小的孩子，用child进行标记
  117.             // 注意：parent的右孩子可能不存在
  118.             // 调用比较器来进行比较
  119.             if(child+1 < size && comparator.compare((E)hp[child+1], (E)hp[child]) < 0 ){
  121.                 child += 1;
  122.             }
  123. // 如果双亲比较小的孩子还大，将双亲与较小的孩子交换
  124.             if(comparator.compare((E)hp[child], (E)hp[parent]) < 0) {
  126.                 swap((E[])hp, child, parent);
  127.                 // 小的元素往下移动，可能导致parent的子树不满足堆的性质
  128.                 // 因此：需要继续向下调整
  129.                 parent = child;
  130.                 child = child*2 + 1;
  131.             }
  132.             else{
  134.                 return;
  135.             }
  136.         }
  137.     }
  138.     // 使用compareTo比较
  139.     private void shiftDownWithcompareTo(int parent){
  141.         // child作用：标记最小的孩子
  142.         // 因为堆是一个完全二叉树，而完全二叉树可能有左没有有
  143.         // 因此：默认情况下，让child标记左孩子
  144.         int child = parent * 2 + 1;
  145.         // while循环条件可以一直保证parent左孩子存在，但是不能保证parent的右孩子存在
  146.         while(child < size)
  147.         {
  149.             // 找parent的两个孩子中最小的孩子，用child进行标记
  150.             // 注意：parent的右孩子可能不存在
  151.             // 向上转型，因为E的对象都实现了Comparable接口
  152.             if(child+1 < size && ((Comparable<? super E>)hp[child]).
  153.             compareTo((E)hp[child])< 0){
  155.                 child += 1;
  156.             }
  157.             // 如果双亲比较小的孩子还大，将双亲与较小的孩子交换
  158.             if(((Comparable<? super E>)hp[child]).compareTo((E)hp[parent]) < 0){
  160.                 swap((E[])hp, child, parent);
  161.             // 小的元素往下移动，可能导致parent的子树不满足堆的性质
  162.             // 因此：需要继续向下调整
  163.                 parent = child;
  164.                 child = child*2 + 1;
  165.             }
  166.             else{
  168.                 return;
  169.             }
  170.         }
  171.     }
  172.     // 向上调整
  173.     void shiftUp(int child){
  175.         if(null == comparator){
  177.             shiftUpWithCompareTo(child);
  178.         }
  179.         else{
  181.             shiftUpWithComparetor(child);
  182.         }
  183.     }
  184.     void shiftUpWithComparetor(int child){
  186.         // 获取孩子节点的双亲
  187.         int parent = ((child-1)>>1);
  188.         while(0 != child){
  190.         // 如果孩子比双亲还小，则不满足小堆的性质，交换
  191.             if(comparator.compare((E)hp[child], (E)hp[parent]) < 0){
  193.                 swap((E[])hp, child, parent);
  194.                 child = parent;
  195.                 parent = ((child-1)>>1);
  196.             }
  197.             else{
  199.                 return;
  200.             }
  201.         }
  202.     }
  203.     void shiftUpWithCompareTo(int child){
  205.         // 获取孩子节点的双亲
  206.         int parent = ((child-1)>>1);
  207.         while(0 != child){
  209.         // 如果孩子比双亲还小，则不满足小堆的性质，交换
  210.             if(((Comparable<? super E>)hp[child]).compareTo((E)hp[parent]) < 0){
  212.                 swap((E[])hp, child, parent);
  213.                 child = parent;
  214.                 parent = ((child-1)>>1);
  215.             }
  216.             else{
  218.                 return;
  219.             }
  220.         }
  221.     }
  222.     void swap(E[] hp, int i, int j){
  224.         E temp = hp[i];
  225.         hp[i] = hp[j];
  226.         hp[j] = temp;
  227.     }
  228.     // 仿照JDK8中的扩容方式，注意还是有点点的区别，具体可以参考源代码
  229.     void grow(){
  231.         int oldCapacity = hp.length;
  232.         if(size() >= oldCapacity){
  234.         // Double size if small; else grow by 50%
  235.             int newCapacity = oldCapacity + ((oldCapacity < 64) ?
  236.                     (oldCapacity + 2) :
  237.                     (oldCapacity >> 1));
  238.             hp = Arrays.copyOf(hp, newCapacity);
  239.         }
  240.     }
  241.     public static void main(String[] args) {
  243.         int[] arr = {
  244.     4,1,9,2,8,0,7,3,6,5};
  245.         // 小堆---采用比较器创建小堆
  246.         MyPriorityQueue<Integer> mq1 = new MyPriorityQueue(new LessIntComp());
  247.         for(int e : arr){
  249.             mq1.offer(e);
  250.         }
  251.         // 大堆---采用比较器创建大堆
  252.         MyPriorityQueue<Integer> mq2 = new MyPriorityQueue(new GreaterIntComp());
  253.         for(int e : arr){
  255.             mq2.offer(e);
  256.         }
  257.         // 小堆--采用CompareTo比较创建小堆
  258.         MyPriorityQueue<Integer> mq3 = new MyPriorityQueue();
  259.         for(int e : arr){
  261.             mq3.offer(e);
  262.         }
  263.     }
  264. }

202304211053809.png

感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！?

发表评论

表情：
评论列表 （有 0 条评论，142人围观）

还没有评论，来说两句吧...

相关阅读

    相关 java对象的比较

    本文章主要介绍了Java对象的比较，首先我们介绍了元素和对象之间分别是如何比较的，然后我们讲解了继承Comparable接口进行比较，最后讲解了什么是PriorithQu...

    男娘i男娘i/ 0 赞/ 143 阅读

    相关 Java - 对象的比较

    一、问题提出 > 前面讲了优先级队列，优先级队列在插入元素时有个要求：插入的元素不能是null或者元素之间必须要能够进行比较，为了简单起见，我们只是插入了Integer类

    红太狼红太狼/ 0 赞/ 176 阅读

    相关 Java中对象的比较

    一 点睛 在Java中，有两种方式可用于对象间的比较： 利用"=="运算符：用于比较两个对象的内存地址值（引用值）是否相等。 利用equals()方法：用于比较

    你的名字你的名字/ 0 赞/ 394 阅读