java中各種對(duì)象的比較方法

更新時(shí)間：2023年04月26日 12:01:18 作者：曉星航

Java對(duì)象的比較是初學(xué)者不易掌握的,下面這篇文章主要給大家介紹了關(guān)于java中各種對(duì)象的比較方法,文中通過實(shí)例代碼以及圖文介紹的非常詳細(xì),需要的朋友可以參考下

前言

今天為大家?guī)?lái)的是 java對(duì)象的比較相關(guān)內(nèi)容的講解！??

1. 問題提出

上節(jié)課我們講了優(yōu)先級(jí)隊(duì)列，優(yōu)先級(jí)隊(duì)列在插入元素時(shí)有個(gè)要求：插入的元素不能是null或者元素之間必須要能夠進(jìn)行比較，為了簡(jiǎn)單起見，我們只是插入了Integer類型，那優(yōu)先級(jí)隊(duì)列中能否插入自定義類型對(duì)象呢？

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.offer(new Card(1, "?"));
        p.offer(new Card(2, "?"));
    }
    public static void main(String[] args) {
        TestPriorityQueue();
    }
}

優(yōu)先級(jí)隊(duì)列底層使用堆，而向堆中插入元素時(shí)，為了滿足堆的性質(zhì)，必須要進(jìn)行元素的比較，而此時(shí)Card是沒有辦法直接進(jìn)行比較的，因此拋出異常。

2. 元素的比較

2.1 基本類型的比較

在Java中，基本類型的對(duì)象可以直接比較大小。

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 對(duì)象的比較

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); // 編譯報(bào)錯(cuò)
        System.out.println(c1 == c2); 
        // 編譯成功 ----> 打印false，因?yàn)閏1和c2指向的是不同對(duì)象
      //System.out.println(c1 < c2); // 編譯報(bào)錯(cuò)
        System.out.println(c1 == c3); 
        // 編譯成功 ----> 打印true，因?yàn)閏1和c3指向的是同一個(gè)對(duì)象
    }
}

c1、c2和c3分別是Card類型的引用變量，上述代碼在比較編譯時(shí)：

c1 > c2 編譯失敗

c1== c2 編譯成功

c1 < c2 編譯失敗

從編譯結(jié)果可以看出，Java中引用類型的變量不能直接按照 > 或者 < 方式進(jìn)行比較。 那為什么==可以比較？

因?yàn)椋?strong>對(duì)于用戶實(shí)現(xiàn)自定義類型，都默認(rèn)繼承自O(shè)bject類，而Object類中提供了equal方法，而==默認(rèn)情況下調(diào)用的就是equal方法，但是該方法的比較規(guī)則是：沒有比較引用變量引用對(duì)象的內(nèi)容，而是直接比較引用變量的地址，但有些情況下該種比較就不符合題意。

// Object中equal的實(shí)現(xiàn)，可以看到：直接比較的是兩個(gè)引用變量的地址
public boolean equals(Object obj) {
        return (this == obj);
        }

3. 對(duì)象的比較

有些情況下，需要比較的是對(duì)象中的內(nèi)容，比如：向優(yōu)先級(jí)隊(duì)列中插入某個(gè)對(duì)象時(shí)，需要對(duì)按照對(duì)象中內(nèi)容來(lái)調(diào)整堆，那該如何處理呢？

3.1 覆寫基類的equal

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對(duì)象，或者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 的套路就是上面演示的

如果指向同一個(gè)對(duì)象，返回 true
如果傳入的為 null，返回 false
如果傳入的對(duì)象類型不是 Card，返回 false
按照類的實(shí)現(xiàn)目標(biāo)完成比較，例如這里只要花色和數(shù)值一樣，就認(rèn)為是相同的牌
注意下調(diào)用其他引用類型的比較也需要 equals，例如這里的 suit 的比較

覆寫基類equal的方式雖然可以比較，但缺陷是：equal只能按照相等進(jìn)行比較，不能按照大于、小于的方式進(jìn)行比較。

3.2 基于Comparble接口類的比較

Comparble是JDK提供的泛型的比較接口類，源碼實(shí)現(xiàn)具體如下：

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

對(duì)用用戶自定義類型，如果要想按照大小與方式進(jìn)行比較時(shí)：在定義類時(shí)，實(shí)現(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)行比較，具體步驟如下：

用戶自定義比較器類，實(shí)現(xiàn)Comparator接口

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

注意：區(qū)分Comparable和Comparator。

覆寫Comparator中的compare方法

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, "?");
// 定義比較器對(duì)象
        CardComparator cmptor = new CardComparator();
// 使用比較器對(duì)象進(jìn)行比較
        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 包中的泛型接口類，使用時(shí)必須導(dǎo)入對(duì)應(yīng)的包。

3.4 三種方式對(duì)比

4. 集合框架中PriorityQueue的比較方式

集合框架中的PriorityQueue底層使用堆結(jié)構(gòu)，因此其內(nèi)部的元素必須要能夠比大小，PriorityQueue采用了：Comparble和Comparator兩種方式。

Comparble是默認(rèn)的內(nèi)部比較方式，如果用戶插入自定義類型對(duì)象時(shí)，該類對(duì)象必須要實(shí)現(xiàn)Comparble接口，并覆寫compareTo方法
用戶也可以選擇使用比較器對(duì)象，如果用戶插入自定義類型對(duì)象時(shí)，必須要提供一個(gè)比較器類，讓該類實(shí)現(xiàn)Comparator接口并覆寫compare方法。

// JDK中PriorityQueue的實(shí)現(xiàn)：
public class PriorityQueue<E> extends AbstractQueue<E>
        implements java.io.Serializable {
    // ...
// 默認(rèn)容量
    private static final int DEFAULT_INITIAL_CAPACITY = 11;
    // 內(nèi)部定義的比較器對(duì)象，用來(lái)接收用戶實(shí)例化PriorityQueue對(duì)象時(shí)提供的比較器對(duì)象
    private final Comparator<? super E> comparator;
    // 用戶如果沒有提供比較器對(duì)象，使用默認(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)整：
// 如果用戶沒有提供比較器對(duì)象，采用Comparable進(jìn)行比較
// 否則使用用戶提供的比較器對(duì)象進(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;
    }
    // 使用用戶提供的比較器對(duì)象進(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;
    }
}

5. 模擬實(shí)現(xiàn)PriorityQueue

class LessIntComp implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2;
    }
}
class GreaterIntComp implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1;
    }
}
// 假設(shè)：創(chuàng)建的是小堆----泛型實(shí)現(xiàn)
public class MyPriorityQueue<E> {
    private Object[] hp;
    private int size = 0;
    private Comparator<? super E> comparator = null;
    // java8中：優(yōu)先級(jí)隊(duì)列的默認(rèn)容量是11
    public MyPriorityQueue(Comparator<? super E> com) {
        hp = new Object[11];
        size = 0;
        comparator = com;
    }
    public MyPriorityQueue() {
        hp = new Object[11];
        size = 0;
        comparator = null;
    }
    // 按照指定容量設(shè)置大小
    public MyPriorityQueue(int capacity) {
        capacity = capacity < 1 ? 11 : capacity;
        hp = new Object[capacity];
        size = 0;
    }
    // 注意：沒有此接口，給學(xué)生強(qiáng)調(diào)清楚
    // java8中：可以將一個(gè)集合中的元素直接放到優(yōu)先級(jí)隊(duì)列中
    public MyPriorityQueue(E[] array){
        // 將數(shù)組中的元素放到優(yōu)先級(jí)隊(duì)列底層的容器中
        hp = Arrays.copyOf(array, array.length);
        size = hp.length;
        // 對(duì)hp中的元素進(jìn)行調(diào)整
        // 找到倒數(shù)第一個(gè)非葉子節(jié)點(diǎn)
        for(int root = ((size-2)>>1); root >= 0; root--){
            shiftDown(root);
        }
    }
    // 插入元素
    public void offer(E val){
        // 先檢測(cè)是否需要擴(kuò)容
        grow();
        // 將元素放在最后位置，然后向上調(diào)整
        hp[size] = val;
        size++;
        shiftUp(size-1);
    }
    // 刪除元素: 刪除堆頂元素
    public void poll(){
        if(isEmpty()){
            return;
        }
        // 將堆頂元素與堆中最后一個(gè)元素進(jìn)行交換
        swap((E[])hp, 0, size-1);
        // 刪除最后一個(gè)元素
        size--;
        // 將堆頂元素向下調(diào)整
        shiftDown(0);
    }
    public int size(){
        return size;
    }
    public E peek(){
        return (E)hp[0];
    }
    boolean isEmpty(){
        return 0 == size;
    }
    // 向下調(diào)整
    private void shiftDown(int parent){
        if(null == comparator){
            shiftDownWithcompareTo(parent);
        }
        else{
            shiftDownWithComparetor(parent);
        }
    }
    // 使用比較器比較
    private void shiftDownWithComparetor(int parent){
        // child作用：標(biāo)記最小的孩子
        // 因?yàn)槎咽且粋€(gè)完全二叉樹，而完全二叉樹可能有左沒有有
        // 因此：默認(rèn)情況下，讓child標(biāo)記左孩子
        int child = parent * 2 + 1;
        // while循環(huán)條件可以一直保證parent左孩子存在，但是不能保證parent的右孩子存在
        while(child < size)
        {
            // 找parent的兩個(gè)孩子中最小的孩子，用child進(jìn)行標(biāo)記
            // 注意：parent的右孩子可能不存在
            // 調(diào)用比較器來(lái)進(jìn)行比較
            if(child+1 < size && comparator.compare((E)hp[child+1], (E)hp[child]) < 0 ){
                child += 1;
            }
// 如果雙親比較小的孩子還大，將雙親與較小的孩子交換
            if(comparator.compare((E)hp[child], (E)hp[parent]) < 0) {
                swap((E[])hp, child, parent);
                // 小的元素往下移動(dòng)，可能導(dǎo)致parent的子樹不滿足堆的性質(zhì)
                // 因此：需要繼續(xù)向下調(diào)整
                parent = child;
                child = child*2 + 1;
            }
            else{
                return;
            }
        }
    }
    // 使用compareTo比較
    private void shiftDownWithcompareTo(int parent){
        // child作用：標(biāo)記最小的孩子
        // 因?yàn)槎咽且粋€(gè)完全二叉樹，而完全二叉樹可能有左沒有有
        // 因此：默認(rèn)情況下，讓child標(biāo)記左孩子
        int child = parent * 2 + 1;
        // while循環(huán)條件可以一直保證parent左孩子存在，但是不能保證parent的右孩子存在
        while(child < size)
        {
            // 找parent的兩個(gè)孩子中最小的孩子，用child進(jìn)行標(biāo)記
            // 注意：parent的右孩子可能不存在
            // 向上轉(zhuǎn)型，因?yàn)镋的對(duì)象都實(shí)現(xiàn)了Comparable接口
            if(child+1 < size && ((Comparable<? super E>)hp[child]).
            compareTo((E)hp[child])< 0){
                child += 1;
            }
            // 如果雙親比較小的孩子還大，將雙親與較小的孩子交換
            if(((Comparable<? super E>)hp[child]).compareTo((E)hp[parent]) < 0){
                swap((E[])hp, child, parent);
            // 小的元素往下移動(dòng)，可能導(dǎo)致parent的子樹不滿足堆的性質(zhì)
            // 因此：需要繼續(xù)向下調(diào)整
                parent = child;
                child = child*2 + 1;
            }
            else{
                return;
            }
        }
    }
    // 向上調(diào)整
    void shiftUp(int child){
        if(null == comparator){
            shiftUpWithCompareTo(child);
        }
        else{
            shiftUpWithComparetor(child);
        }
    }
    void shiftUpWithComparetor(int child){
        // 獲取孩子節(jié)點(diǎn)的雙親
        int parent = ((child-1)>>1);
        while(0 != child){
        // 如果孩子比雙親還小，則不滿足小堆的性質(zhì)，交換
            if(comparator.compare((E)hp[child], (E)hp[parent]) < 0){
                swap((E[])hp, child, parent);
                child = parent;
                parent = ((child-1)>>1);
            }
            else{
                return;
            }
        }
    }
    void shiftUpWithCompareTo(int child){
        // 獲取孩子節(jié)點(diǎn)的雙親
        int parent = ((child-1)>>1);
        while(0 != child){
        // 如果孩子比雙親還小，則不滿足小堆的性質(zhì)，交換
            if(((Comparable<? super E>)hp[child]).compareTo((E)hp[parent]) < 0){
                swap((E[])hp, child, parent);
                child = parent;
                parent = ((child-1)>>1);
            }
            else{
                return;
            }
        }
    }
    void swap(E[] hp, int i, int j){
        E temp = hp[i];
        hp[i] = hp[j];
        hp[j] = temp;
    }
    // 仿照J(rèn)DK8中的擴(kuò)容方式，注意還是有點(diǎn)點(diǎn)的區(qū)別，具體可以參考源代碼
    void grow(){
        int oldCapacity = hp.length;
        if(size() >= oldCapacity){
        // Double size if small; else grow by 50%
            int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                    (oldCapacity + 2) :
                    (oldCapacity >> 1));
            hp = Arrays.copyOf(hp, newCapacity);
        }
    }
    public static void main(String[] args) {
        int[] arr = {4,1,9,2,8,0,7,3,6,5};
        // 小堆---采用比較器創(chuàng)建小堆
        MyPriorityQueue<Integer> mq1 = new MyPriorityQueue(new LessIntComp());
        for(int e : arr){
            mq1.offer(e);
        }
        // 大堆---采用比較器創(chuàng)建大堆
        MyPriorityQueue<Integer> mq2 = new MyPriorityQueue(new GreaterIntComp());
        for(int e : arr){
            mq2.offer(e);
        }
        // 小堆--采用CompareTo比較創(chuàng)建小堆
        MyPriorityQueue<Integer> mq3 = new MyPriorityQueue();
        for(int e : arr){
            mq3.offer(e);
        }
    }
}