Java數(shù)據(jù)結(jié)構(gòu)之對象比較詳解
更新時間：2022年07月18日 14:34:06 作者：每天都要寫代碼'
這篇文章主要為大家詳細(xì)介紹了Java中對象的比較、集合框架中PriorityQueue的比較方式以及PriorityQueue的模擬實現(xiàn)，感興趣的可以了解一下
本篇博客主要內(nèi)容：
- Java中對象的比較
- 集合框架中PriorityQueue的比較方式
- 模擬實現(xiàn)PriorityQueue
1. PriorityQueue中插入對象
優(yōu)先級隊列在插入元素時有個要求：插入的元素不能是null或者元素之間必須要能夠 進(jìn)行比較，為了簡單起見，我們只是插入了Integer類型，那優(yōu)先級隊列中能否插入自定義類型對象呢？
class Card {
public int rank; // 數(shù)值
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.o?er(new Card(1, "?"));
p.o?er(new Card(2, "?"));
}
public static void main(String[] args) {
TestPriorityQueue();
}
}
優(yōu)先級隊列底層使用堆，而向堆中插入元素時，為了滿足堆的性質(zhì)，必須要進(jìn)行元素的比較，而此時Card是沒有辦法直接進(jìn)行比較的，因此拋出異常。
2. 元素的比較
2.1 基本類型的比較
在Java中，基本類型的對象可以直接比較大小。
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);
char c1 = 'A';
char c2 = 'B';
System.out.println(c1 > c2);
System.out.println(c1 < c2);
System.out.println(c1 == c2);
boolean b1 = true;
boolean b2 = false;
System.out.println(b1 == b2);
System.out.println(b1 != b2);
}
}
2.2 對象比較的問題
class Card {
public int rank; // 數(shù)值
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指向的是同一個對象 }
}
c1、c2和c3分別是Card類型的引用變量，上述代碼在比較編譯時：
- c1 > c2 編譯失敗
- c1== c2 編譯成功
- c1 < c2 編譯失敗
從編譯結(jié)果可以看出， Java中引用類型的變量不能直接按照 > 或者 < 方式進(jìn)行比較。 那為什么‘==‘可以比較？
因為： 對于用戶實現(xiàn)自定義類型，都默認(rèn)繼承自O(shè)bject類，而Object類中提供了equal方法，而==默認(rèn)情況下調(diào)用的就是equal方法，但是該方法的比較規(guī)則是： 沒有比較引用變量引用對象的內(nèi)容，而是直接比較引用變量的地 址 ，但有些情況下該種比較就不符合題意。
比較引用類型的關(guān)系：
- 大小關(guān)系
- 相等關(guān)系
以撲克牌的數(shù)值和花色為例子：
比較：
//數(shù)值比較器
class RankComparator implements Comparator<Card>{
@Override
public int compare(Card o1, Card o2) {
return o1.rank-o2.rank;
}
}
//花色比較器
class SuitComparator implements Comparator<Card>{
@Override
public int compare(Card o1, Card o2) {
return o1.suit.compareTo(o2.suit);
}
}
public class Test01 {
public static void main(String[] args) {
//數(shù)值比較器
RankComparator rankComparator=new RankComparator();
Card card1=new Card(1,"?");
Card card2=new Card(2,"?");
rankComparator.compare(card1,card2);
//花色比較器
SuitComparator suitComparator=new SuitComparator();
System.out.println(suitComparator.compare(card1,card2));
}
}
// Object中equal的實現(xiàn) ，可以看到：直接比較的是兩個引用變量的地址
public boolean equals(Object obj) {
return (this == obj);
}
判斷相等：
class Card implements Comparable<Card>{
public int rank; // 數(shù)值
public String suit; // 花色
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
public Card() {
super();
}
@Override
public int hashCode() {
return super.hashCode();
}
@Override
public boolean equals(Object obj) {
if(this==obj)return true;
if(obj==null || getClass()!=obj.getClass())return false;
Card card=(Card)obj;
return rank== card.rank && Objects.equals(suit,card.suit);
}
@Override
public int compareTo(Card o) {
return this.rank-o.rank;
}
}
public class Test01 {
public static void main(String[] args) {
Card card1=new Card(1,"?");
Card card2=new Card(2,"?");
System.out.println(card1==card2);//判斷兩張牌的地址是否相等
System.out.println(card1.equals(card2));//判斷兩張牌是否相等
System.out.println(card1.compareTo(card2));//比較兩張牌
}
}
3. 對象的比較
3.1 覆寫基類的equals
public class Card {
public int rank; // 數(shù)值
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;
}
// 注意基本類型可以直接比較 ，但引用類型最好調(diào)用其equal方法
Card c = (Card)o;
return rank == c.rank
&& suit.equals(c.suit);
}
}
注意： 一般覆寫 equals 的套路就是上面演示的
1、如果指向同一個對象，返回 true
2、如果傳入的為 null，返回 false
3、 如果傳入的對象類型不是 Card，返回 false
4、 按照類的實現(xiàn)目標(biāo)完成比較，例如這里只要花色和數(shù)值一樣，就認(rèn)為是相同的牌
5、注意下調(diào)用其他引用類型的比較也需要 equals，例如這里的 suit 的比較
覆寫基類equal的方式雖然可以比較，但缺陷是： equal只能按照相等進(jìn)行比較，不能按照大于、小于的方式進(jìn)行 比較。
3.2 基于Comparble接口類的比較
Comparble是JDK提供的泛型的比較接口類，源碼實現(xiàn)具體如下：
public interface Comparable<E> {
// 返回值:
// < 0: 表示 this 指向的對象小于 o 指向的對象
// == 0: 表示 this 指向的對象等于 o 指向的對象
// > 0: 表示 this 指向的對象大于 o 指向的對象
int compareTo(E o);
}
對于用戶自定義類型，如果要想按照大小與方式進(jìn)行比較時： 在定義類時，實現(xiàn)Comparble接口即可，然后在類 中重寫compareTo方法。
public class Card implements Comparable<Card> { public int rank; // 數(shù)值
public String suit; // 花色
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
// 根據(jù)數(shù)值比較 ，不管花色
// 這里我們認(rèn)為 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 基于比較器比較
按照比較器方式進(jìn)行比較，具體步驟如下：
用戶自定義比較器類，實現(xiàn)Comparator接口
public interface Comparator<T> {
// 返回值:
// < 0: 表示 o1 指向的對象小于 o2 指向的對象
// == 0: 表示 o1 指向的對象等于 o2 指向的對象
// > 0: 表示 o1 指向的對象等于 o2 指向的對象
int compare(T o1, T o2);
}
注意：
區(qū)分Comparable和Comparator。
- 覆寫Comparator中的compare方法。
- Comparator是java.util 包中的泛型接口類，使用時必須導(dǎo)入對應(yīng)的包。
- Compareble是java.lang中的接口類，可以直接使用。
import java.util.Comparator;
class Card {
public int rank; // 數(shù)值
public String suit; // 花色
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
}
class CardComparator implements Comparator<Card> {
// 根據(jù)數(shù)值比較 ，不管花色
// 這里我們認(rèn)為 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();
// 使用比較器對象進(jìn)行比較
System.out.println(cmptor.compare(p, o)); System.out.println(cmptor.compare(p, q)); System.out.println(cmptor.compare(q, p));
}
}
3.4 三種方式的對比
| 覆寫的方法 | 說明 |
|---|---|
| Object.equals | 因為所有類都是繼承自 Object 的，所以直接覆寫即可，不過只能比較相等與 否 |
| Comparable.compareTo | 需要手動實現(xiàn)接口，侵入性比較強(qiáng)，但一旦實現(xiàn)，每次用該類都有順序，屬于內(nèi)部順序 |
| Comparator.compare | 需要實現(xiàn)一個比較器對象，對待比較類的侵入性弱，但對算法代碼實現(xiàn)侵入性強(qiáng) |
4.集合框架中PriorityQueue的比較方式
集合框架中的PriorityQueue底層使用堆結(jié)構(gòu)，因此其內(nèi)部的元素必須要能夠比大小， PriorityQueue采用了： Comparble和Comparator兩種方式。
1.Comparble是默認(rèn)的內(nèi)部比較方式，如果用戶插入自定義類型對象時，該類對象必須要實現(xiàn)Comparble接 口，并覆寫compareTo方法
2.用戶也可以選擇使用比較器對象，如果用戶插入自定義類型對象時，必須要提供一個比較器類，讓該類實現(xiàn) Comparator接口并覆寫compare方法。
// JDK中PriorityQueue的實現(xiàn)：
public class PriorityQueue<E> extends AbstractQueue<E>
implements java.io.Serializable {
// ...
// 默認(rèn)容量
private static ?nal int DEFAULT_INITIAL_CAPACITY = 11;
// 內(nèi)部定義的比較器對象 ，用來接收用戶實例化PriorityQueue對象時提供的比較器對象
private ?nal Comparator<? super E> comparator;
// 用戶如果沒有提供比較器對象 ，使用默認(rèn)的內(nèi)部比較 ，將comparator置為null
public PriorityQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
// 如果用戶提供了比較器 ，采用用戶提供的比較器進(jìn)行比較
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
if (initialCapacity < 1)
throw new IllegalArgumentException();
this.queue = new Object[initialCapacity];
this.comparator = comparator;
}
// ...
// 向上調(diào)整：
// 如果用戶沒有提供比較器對象 ，采用Comparable進(jìn)行比較
// 否則使用用戶提供的比較器對象進(jìn)行比較
private void siftUp(int k, E x) {
if (comparator != null)
siftUpUsingComparator(k, x);
else
siftUpComparable(k, x);
}
// 使用Comparable
@SuppressWarnings("unchecked")
private void siftUpComparable(int k, E x) {
Comparable<? super E> key = (Comparable<? super E>) x;
while (k > 0) {
int parent = (k - 1) >>> 1;
Object e = queue[parent];
if (key.compareTo((E) e) >= 0)
break;
queue[k] = e;
k = parent;
}
queue[k] = key;
}
// 使用用戶提供的比較器對象進(jìn)行比較
@SuppressWarnings("unchecked")
private void siftUpUsingComparator(int k, E x) {
while (k > 0) {
int parent = (k - 1) >>> 1;
Object e = queue[parent];
if (comparator.compare(x, (E) e) >= 0) break;
queue[k] = e;
k = parent;
}
queue[k] = x;
}
}到此這篇關(guān)于Java數(shù)據(jù)結(jié)構(gòu)之對象比較詳解的文章就介紹到這了,更多相關(guān)Java對象比較內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
Redis集群實現(xiàn)了對Redis的水平擴(kuò)容，即啟動N個redis節(jié)點，將整個數(shù)據(jù)庫分布存儲在這N個節(jié)點中，每個節(jié)點存儲總數(shù)據(jù)的1/N。Redis集群通過分區(qū)來提供一定程度的可用，即使集群中有一部分節(jié)點失效或者無法進(jìn)行通訊，集群也可以繼續(xù)處理命令請求2022-12-12
這篇文章主要介紹了Java編程中10個最佳的異常處理技巧,在本文中,將討論Java異常處理最佳實踐,這些Java最佳實踐遵循標(biāo)準(zhǔn)的JDK庫,和幾個處理錯誤和異常的開源代碼,這還是一個提供給java程序員編寫健壯代碼的便利手冊,需要的朋友可以參考下2015-01-01
區(qū)塊鏈?zhǔn)欠植际綌?shù)據(jù)存儲、點對點傳輸、共識機(jī)制、加密算法等計算機(jī)技術(shù)的新型應(yīng)用模式,下面這篇文章主要給大家介紹了基于Java實現(xiàn)區(qū)塊鏈的相關(guān)資料,需要的朋友可以參考下2021-08-08
這篇文章主要介紹了Springboot?多租戶SaaS方案，本文給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值,需要的朋友可以參考下2022-06-06
這篇文章主要介紹了idea 解決用骨架創(chuàng)建項目過慢的操作方式，具有很好的參考價值，希望對大家有所幫助。一起跟隨小編過來看看吧2020-08-08
本文是通過一個簡單的實例，向大家介紹了Try {} Catch{}的意義和作用，非常的實用，有需要的小伙伴可以參考下。2015-10-10
Spring Security實現(xiàn)身份認(rèn)證和授權(quán)的示例代碼
在 Spring Boot 應(yīng)用中使用 Spring Security 可以非常方便地實現(xiàn)用戶身份認(rèn)證和授權(quán)，本文主要介紹了Spring Security實現(xiàn)身份認(rèn)證和授權(quán)的示例代碼，感興趣的可以了解一下2023-06-06
這篇文章主要給大家介紹了關(guān)于SpringBoot項目啟動報錯踩坑的相關(guān)資料,文中通過實例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友可以參考下2023-02-02
這篇文章主要介紹了在java的Map集合中,如何更改value的值問題,具有很好的參考價值,希望對大家有所幫助,如有錯誤或未考慮完全的地方,望不吝賜教2023-09-09
這篇文章主要介紹了.NET程序員如何快入門Spring Boot,微軟給VS Code提供了編寫Java的插件，你可以在VS Code上愉快地寫Java。,需要的朋友可以參考下2019-06-06