1.PriorityQueue中插入对象

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

public 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 TestPriorityQueue(){
        PriorityQueue<Card> p= new PriorityQueue<>();
        p.offer(new Card(1,"?"));
        p.offer(new Card(2,"?"));

    }

    public static void main(String[] args) {
        TestPriorityQueue();
    }
}

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

2.元素的比较

2.1 基本类型的比较

public class TestCompare {
    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);
        System.out.println("========================");
        char c1='A';
        char c2='B';
        

        System.out.println(c1>c2);
        System.out.println(c1<c2);
        System.out.println(c1==c2);
        System.out.println("========================");

        boolean b1=true;
        boolean b2=false;
        System.out.println(b1==b2);
        System.out.println(b1!=b2);
    }
}

2.2 对象比较的问题

public 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) {
        //TestPriorityQueue();
        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类中提供了equals方法，而= =默认情况下调用的就是equals方法。但是该方法的比较规则是：没有比较引用变量引用对象的内容，而是直接比较引用变量的地址，

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

3.对象的比较

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

3.1 覆写基类的equals

public class Card {
    public int rank;//数值
    public String suit;//花色

    public Card(int rank, String suit){
        this.rank=rank;
        this.suit=suit;
    }

    @Override
    public boolean equals(Object o) {
        //自己和自己比较
        if(this==o){
            return true;
        }

        //o如果是null对象，或者o不是Card的子类
        if(o==null|| !(o instanceof Card)){
            return false;
        }

        //注意基本类型可以直接比较，但引用类型最好调用其equals方法
        Card c=(Card)o;
        return rank==c.rank && suit.equals(c.suit);
    }
}

注意：一般覆写equals就是上述代码演示的

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

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

3.2 基于Comparble接口类的比较

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

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

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

public class Card implements Comparable<Card>{
    public int rank;//数值
    public String suit;//花色

    public Card(int rank, String suit){
        this.rank=rank;
        this.suit=suit;
    }

    //根据数值比较，不管花色
    //在这里我们认为null是最小的
    @Override
    public int compareTo(Card o) {
        if(o==null){
            return 1;
        }
        return rank-o.rank;
    }

    public static void main(String[] args) {
        Card p=new Card(1,"?");
        Card q=new Card(2,"?");
        Card o=new Card(1,"?");
        System.out.println(p.compareTo(o));//==0 表示牌相等
        System.out.println(p.compareTo(q));//<0 表示p比较小
        System.out.println(q.compareTo(p));//>0 表示q比较大
    }
}

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

3.3 基于比较器比较

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

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

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

注意：区分Comparable和Comparator

覆写Comparator中的compare方法

import java.util.Comparator;
public class CardComparator implements Comparator<Card>{
    
    //根据数值比较，不管花色
    //在这里我们认为null是最小的
    @Override
    public int compare(Card o1, Card o2) {
        if(o1==o2){
            return 0;
        }
        
        if(o1==null){
            return -1;
        }
        
        if(o2==null){
            return 1;
        }
        return o1.rank-o2.rank;
    }

    public static void main(String[] args) {
        Card p= new Card(1,"?");
        Card q= new Card(2,"?");
        Card o= new Card(1,"?");
        //定义比较器对象
        CardComparator cmptor=new CardComparator();
        //使用比较器对象进行比较
        System.out.println(cmptor.compare(p,o));//==0表示牌相等
        System.out.println(cmptor.compare(p,q));//<0表示p比较小
        System.out.println(cmptor.compare(q,p));//>0表示q比较大

    }
}

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

3.4 三种方式对比

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