前言：
🌟🌟Hello家人们，这期讲解对象的比较，以及优先级队列堆，希望你能帮到屏幕前的你。
🌈上期博客在这里：http://t.csdnimg.cn/MSex7
🌈感兴趣的小伙伴看一看小编主页：GGBondlctrl-CSDN博客
目录
📚️1. PriorityQueue中插入对象
📚️2元素的比较
2.1基本类型的比较
2.2对象比较问题
1.通过比较运算符
2.通过equals比较
📚️3.对象的比较
3.1重写基类的equals方法
3.2基于Comparble接口类的比较
3.3基于比较器进行比较
3.4三种比较方式
📚️4.PriorityQueue的比较方式
4.1PriorityQueue的比较
4.2PriorityQueue大小堆解决topK问题
📚️总结
📚️1. PriorityQueue中插入对象
上期博客讲了优先级队列，优先级队列在插入元素时有个要求：插入的元素不能是null或者元素之间必须要能够进行比较，为了简单起见，我们只是插入了Integer类型，那优先级队列中能否插入自定义类型对象呢？
代码如下：
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基本类型的比较
在Java中基本数据类型可以直接进行比较，一般通过>,<或者==来进行判断，放回值为boolean类型，小编这里就不再过多解释，相信大家因该了解了。
2.2对象比较问题
1.通过比较运算符
代码如下：
Student student=new Student(12,"zhangsan");
Student student1=new Student(12,"zhangsan");
System.out.println(student1==student);此时输出的值为false；
因为在“==”在实质上是比较的两个对象的地址，很明显这两个同学并不是同一个地址的，他们两个都new了一个地址出来，所以该地输出为false。
2.通过equals比较
代码如下：
Student student=new Student(12,"zhangsan");
Student student1=new Student(12,"zhangsan");
System.out.println(student1.equals(student));
此时输出为false；
在这里，我们可以通过内部原理进行解析：
对于用户实现自定义类型，都默认继承自Object类，而Object类中提供了equal方法，而==默认情况下调用的就是equal方法，但是该方法的比较规则是：没有比较引用变量引用对象的内容，而是直接比较引用变量的地址
内部原理代码如下：
在这里this为student1,因为是student1调用函数与另一个学生进行比较，此时student就为obj。那么结果到头来还是地址的比较，所以还是为不等false 。
📚️3.对象的比较
3.1重写基类的equals方法
代码如下：
class Student{
public int age;
public String name;
public Student(int age,String name){
this.age=age;
this.name=name;
}
@Override //进行重写
public boolean equals(Object o) {
if (this == o) return true;
if(o==null||!(o instanceof Student)){
return false;
}
Student student=(Student) o;
return age==student.age&&name==student.name;
}
}在这里第一个条件：如果是自己调用自己那么就一定相等
在这里第二个条件：如果括号里的对象是空的，或者不是student的子类，那么就不相等
在这里最后的情况：实现强转，并且通过调用其年龄，和名字进行比较，并返回，实现equals重写
覆写基类equal的方式虽然可以比较，但缺陷是：equal只能按照相等进行比较，不能按照大于、小于的方式进行比较
3.2基于Comparble接口类的比较
对用用户自定义类型，如果要想按照大小与方式进行比较时：在定义类时，实现Comparble接口即可，然后在类中重写compareTo方法。
代码如下：
class Card implements Comparable<Card>{
public int rank;
public String suit;
public Card(int rank,String suit) {
this.rank=rank;
this.suit=suit;
}
public int compareTo(Card o){
return rank-o.rank;
}
}
public class test {
public static void main(String[] args) {
Card card=new Card(5,"♥");
Card card1=new Card(5,"♥");
System.out.println(card.compareTo(card1));
}
}在重写compareTo方法时，是通过两者的大小进行比较，返回如果是一个正数，那么前者比后者更大，反之如果为一个负数那么就是后者更大，为0那么表示两者相同。
3.3基于比较器进行比较
用户自定义比较器类，实现Comparator接口，并且重写Comparator中的compare方法
代码如下：
class Agecompare implements Comparator<Student>{
public int compare(Student s1,Student s2){
return s1.age-s2.age;
}
}
class Namecompare implements Comparator<Student>{
public int compare(Student s1,Student s2){
return s1.name.compareTo(s2.name);
}
}
public class test {
public static void main(String[] args) {
Agecompare agecompare=new Agecompare();
Namecompare namecompare=new Namecompare();
Student student2=new Student(12,"lisi");
Student student3=new Student(12,"lisi");
System.out.println(agecompare.compare(student2,student3));
System.out.println(namecompare.compare(student2,student3));
}
}这里要单独定义类来实现接口，并且重写接口当中的方法，在进行比较时对定义的类进行实例化，并且通过对应对象调用重写的compare方法，然后传递参数即可。
注意：但是在用对像调用时，名字为string类不能够相减，此时string引用类型compareto方法进行比较。因为string实现了comparable接口，重写了compareto方法。
3.4三种比较方式
覆写的方法：
Object.equals因为所有类都是继承自 Object 的，所以直接覆写即可，不过只能比较相等与否
Comparable.compareTo
需要手动实现接口，侵入性比较强，但一旦实现，每次用该类都有顺序，属于内部顺序
Comparator.compare
需要实现一个比较器对象，对待比较类的侵入性弱，但对算法代码实现侵入性强
📚️4.PriorityQueue的比较方式
4.1PriorityQueue的比较
当我们实现了compareor接口，并且重写了内部方法后，在PriorityQueue中如何实现添加对象呢？
代码如下：
class Agecompare implements Comparator<Student>{
public int compare(Student s1,Student s2){
return s1.age-s2.age;
}
}
public class test {
public static void main(String[] args) {
Agecompare agecompare=new Agecompare();
PriorityQueue<Student> p=new PriorityQueue<>(agecompare);
p.offer(student);
p.offer(student1);
System.out.println(p.peek());
p.poll();
System.out.println(p.peek());
}
}此时我们需要实例化实现接口的类，并将比较器的实例作为参数传入，此时就能够传入学生对象了，但是输出是学生对象的地址，并没有实际意义。
4.2PriorityQueue大小堆解决topK问题
大小堆的接口实现：
class MaxHeap implements Comparator<Integer>{ //创建大堆
public int compare(Integer o1,Integer o2){
return o2-o1;
}
}
class MinHeap implements Comparator<Integer>{ //创建小堆
public int compare(Integer o1,Integer o2){
return o1-o2;
}
}思路：在需要输出前K个最小的数目时，我们要创建大根堆，前k个数字组成的大根堆，当后面数字与堆顶元素比较时（堆顶元素最大）如果小于堆顶元素，那么就删除堆顶元素，将更小的元素传入堆中，那么在遍历完数组后，前K个组成的堆中就是最小的元素。
代码如下：
class MintTopK {
public void mink(int[] array,int k){
if(k<=0){
return;
}
MaxHeap maxHeap=new MaxHeap();
PriorityQueue<Integer> q=new PriorityQueue<>(maxHeap);
//创建一个大根堆（前k个值）
for (int i = 0; i < k; i++) {
q.offer(array[i]);
}
//堆剩下的数据进行操作
for (int i = k; i < array.length ; i++) {
if(array[i]<q.peek()){
q.poll();
q.offer(array[i]);
}
}
//开始输出前k个数
for (int i = 0; i <k ; i++) {
int ret=q.poll();
System.out.print(ret+" ");
}
}
}
public class test {
public static void main(String[] args) {
int[] array={1,4,3,2,9};
MintTopK mintTopK=new MintTopK();
mintTopK.mink(array,3);
}
}那么此时的输出就为3 2 1；
📚️总结
💬💬小编这期主要讲解了对象的比较方式，以及优先级队列如何进行对象的插入，以及大小堆的创建，实现topK问题的解决。
对于优先级队列看似是二叉树的内容，但是实质上是数组的运用，在进行对象的比较时，也可以从源码进行理解，每种比较方式都有好坏，主要还是看情况哦~~~
🌅🌅🌅~~~~最后希望与诸君共勉，共同进步！！！
💪💪💪以上就是本期内容了， 感兴趣的话，就关注小编吧。
😊😊 期待你的关注~~~
