【一起来学java数据结构】——对象的比较（priority Queue）

一起来学java——对象的比较（priority Queue）

因为优先级队列是需要比较里面的值的大小的，所以当我们自定义类型的时候，要根据自定义类型中的某一个成员的值来进行优先级队列，这个时候就涉及到了比较这个成员变量的大小的问题，今天我们解决的就是这个问题

大致是有以下三个方法：

• equals函数：只能比较两个对象的值是不是相同的，不能比较大小
• 让该自定义的类实现compable接口，并重写compareTo方法

实现Comparable接口

让自定义的类实现Comparable接口，并重写CompareTo函数，这样就可以完成指定元素的比较

下面这个compareTo函数是以card的rank进行排序的

import java.util.PriorityQueue;

class Card implements Comparable<Card> {
    //ctrl+I重写接口
    @Override
    public int compareTo(Card o) {
        return this.rank-o.rank;
    }

    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }

    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
}
public class TestCardCampare {
    public static void main(String[] args) {
        PriorityQueue<Card> pq=new PriorityQueue<>();
        pq.offer(new Card(1,"♥"));
        pq.offer(new Card(2,"♦"));
        System.out.println(pq);
    }
}

上面的就是采用comparable的比较方法来进行的。就是让类实现comparable接口，然后重写CompareTo函数就可以了

但是上面的这种方法有一种弊端，就是对类的侵入性太大，破坏了类的内部

实现Comparator

下面还有一种方法就是另外建立一个类，然后使用这个新建立的类进行比较

然后优先队列创建对象的时候参数是我们刚才创建的那个类

//使用comparator来进行
class Card{
    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
}
//新建立一个类来实现comparator来帮助card进行比较
class RankComparator implements Comparator<Card>{
    @Override
    public int compare(Card o1, Card o2) {
        return o1.rank-o2.rank;
    }
}
public class TestCardCampare {
    public static void main(String[] args) {
        RankComparator rankComparator=new RankComparator();
        Card card1=new Card(1,"a");
        Card card2=new Card(2,"b");
 		//参数使用刚才建立的比较器类
        PriorityQueue priorityQueue=new PriorityQueue(rankComparator);
        priorityQueue.offer(card1);
        priorityQueue.offer((card2));
        System.out.println(priorityQueue);
    }
}

还有一种使用匿名的比较器类

public class TestCardCampare {
    public static void main(String[] args) {
        Card card1=new Card(1,"a");
        Card card2=new Card(2,"b");
        PriorityQueue<Card> priorityQueue=new PriorityQueue<>(new Comparator<Card>() {
            @Override
            public int compare(Card o1, Card o2) {
                return o1.rank- o2.rank;
            }
        });
        priorityQueue.offer(card1);
        priorityQueue.offer((card2));
        System.out.println(priorityQue	ue);
    }
}

另外还可以使用lambda表达式

public class TestCardCampare {
    public static void main(String[] args) {
        Card card1=new Card(1,"a");
        Card card2=new Card(2,"b");
        PriorityQueue<Card> priorityQueue=new PriorityQueue<>((x,y)->{return x.rank-y.rank;});
        priorityQueue.offer(card1);
        priorityQueue.offer((card2));
        System.out.println(priorityQueue);
    }
}

使用equals判断是否相同

注意：equals只能判断是不是相同的，不能够比较大小

1. 如果使用Object自带的equals函数

public class TestCardCampare {
    public static void main(String[] args) {
        Card card1=new Card(1,"a");
        Card card2=new Card(1,"a");
        System.out.println(card1.equals(card2));
		//false
    }
}

会输出false，因为系统自带的是用来判断引用是不是相同

public boolean equals(Object obj) {
    return (this == obj);
}

2. 重写equals函数

class Card{
    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
	//重写equals函数
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Card card = (Card) o;
        return rank == card.rank && Objects.equals(suit, card.suit);
    }

    @Override
    public int hashCode() {
        return Objects.hash(rank, suit);
    }
}
public class TestCardCampare {
    public static void main(String[] args) {
        Card card1=new Card(1,"a");
        Card card2=new Card(1,"a");
        System.out.println(card1.equals(card2));//true
    }
}

但是当我们在Card中重写equals函数的时候时，就可以返回true了

总结

方法	解释
使用Comparable接口	在类中实现Comparable接口，并重写CompareTo函数，对类的侵入性较强
使用Comparator比较器	自己定义一个比较器函数，重写Compare，然后在构造PriorityQueue中使用该比较器，对类的侵入性较弱
重写equals函数	重写equals函数，但是只能比较两个两个对象是否相同，不可以比较大小