前言

在上篇文章Heap —— Priority Queue - 堆/优先级队列中，优先级队列在插入元素不能是null 或者 元素之间必须要能狗进行比较。

为了简单起见，我们只是插入了 Integer 类型，那优先级队列中能否插入自定义的数据类型对象？

实践

通过实践，我们发现在没有指定 某种排序规则时，是无法将自定义类型入队的。
至于 Comparable，可以参考这篇文章面向对象的编程（三个常用接口）

回顾

关于 对象的比较来说：
1、equals 方法，比较的是对象，如果比较的两个对象不相同：返回 false，反之，返回true
2、比较大小
我们的 Comparable 和 compareTo 使用比较大小的。

总结

因为我们Card类，指定的类型 没有具有指定的比较能力。
所以，我们需要去指定 某种排序的规则。

方法一： 实现Comparable 接口 【注意！实现结结构，是要重写接口内部的抽象方法的】

import java.util.PriorityQueue;

// 扑克牌
class Card implements Comparable<Card>{
    public int point;// 点数
    public String suit;// 花色
    public Card(int point,String suit){
        this.point = point;
        this.suit = suit;
    }
    // 重写 compareTo 方法
    // 按照 point值 的 大小 来比较。
    @Override
    public int compareTo(Card o) {
        return this.point - o.point;
    }
    // 重写 toString 方法
    @Override
    public String toString() {
        return "Card{" +
                "point=" + point +
                ", suit='" + suit + '\'' +
                '}';
    }
}

public class TestDemo {
    public static void main(String[] args) {
        // 默认是 小根堆
        PriorityQueue<Card> priorityQueue = new PriorityQueue<>();
        priorityQueue.offer(new Card(1,"♥"));
        priorityQueue.offer(new Card(2,"♠"));
        System.out.println(priorityQueue);
    }
}

那么，问题来了。我们也没有看见 优先级队列调用 compareTo 啊？
这里我们就需要去看一下，PriorityQueue 的 原码。
既然，自定义类型的数据能放的进去，而且 其结果 是有序的。
那么，说明 offer 在添加 自定义元素时，肯定是比较了的。
所以，我们从 offer 入手。

方法二：创建一个实现类，用来实现 Comparator 接口。通过这个类，来确定比较的规则。

建议使用方法二，方法一 对 程序的侵入性很大，不能随意改动！
而方法二，则避免了这一个问题，将其比较规则封装成一个类。用的时候，直接调用就行。
可参考这篇文章面向对象的编程（三个常用接口）

拓展

利用匿名内部类来实现 - 与上面Comparator 方法 是 等价的。

我还没发过 关于 内部类的博文，所以这里自行琢磨一下。
简单来说：就是 Comparator 那种方法的缩减版本。

lambda 表达式 - 与上一种方法是等价的。

特点就是：比上一种方法更加整洁。但是，阅读性更低。

元素的比较

基本类型的比较

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

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

对象的比较

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指向的是同一个对象
   }
}

总结

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

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

对象比较

equals 方法

public class TestDemo {
    public static void main(String[] args) {
        // 默认是 小根堆
        PointComparator pointComparator = new PointComparator();
        PriorityQueue<Card> priorityQueue = new PriorityQueue<>(pointComparator);
        Card card1 = new Card(1,"♥");
        Card card2 = new Card(1,"♥");
        System.out.println(card1.equals(card2));
   }
}

从代码来看这两张牌 的内容 是一样的。
但是，结果就是不是我们想的那样！

这是因为 我们 Card 类 是 不具有 equals 方法的。
所以，它调用的是 Object 类 的 equals

也就是比较是 地址 / 引用，而不是对象内容。
要想比较对象的内容，也很简单，在 Card 类中，重写equals 方法。
在 Card内部，输入 equals + 回车，然后一直next，直到 finish。

此时，再来比较

总结

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

三种比较方式对比

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

集合框架中PriorityQueue的比较方式

只要你们搞懂了 这篇文章Heap —— Priority Queue 【堆 / 优先队列】就可以了。

本文结束