溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“java中各種對象的比較方法是什么”，在日常操作中，相信很多人在java中各種對象的比較方法是什么問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”java中各種對象的比較方法是什么”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！
上節課我們講了優先級隊列，優先級隊列在插入元素時有個要求：插入的元素不能是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是沒有辦法直接進行比較的，因此拋出異常。
在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);
}
}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) {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 編譯失敗
從編譯結果可以看出，Java中引用類型的變量不能直接按照 > 或者 < 方式進行比較。 那為什么==可以比較？
因為：對于用戶實現自定義類型，都默認繼承自Object類，而Object類中提供了equal方法，而==默認情況下調用的就是equal方法，但是該方法的比較規則是：沒有比較引用變量引用對象的內容，而是直接比較引用變量的地址，但有些情況下該種比較就不符合題意。
// Object中equal的實現，可以看到：直接比較的是兩個引用變量的地址
public boolean equals(Object obj) {
return (this == obj);
}有些情況下，需要比較的是對象中的內容，比如：向優先級隊列中插入某個對象時，需要對按照對象中內容來調整堆，那該如何處理呢？
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;
}
// 注意基本類型可以直接比較，但引用類型最好調用其equal方法
Card c = (Card)o;
return rank == c.rank
&& suit.equals(c.suit);
}
}注意： 一般覆寫 equals 的套路就是上面演示的
如果指向同一個對象，返回 true
如果傳入的為 null，返回 false
如果傳入的對象類型不是 Card，返回 false
按照類的實現目標完成比較，例如這里只要花色和數值一樣，就認為是相同的牌
注意下調用其他引用類型的比較也需要 equals，例如這里的 suit 的比較
覆寫基類equal的方式雖然可以比較，但缺陷是：equal只能按照相等進行比較，不能按照大于、小于的方式進行比較。
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中的接口類，可以直接使用。
按照比較器方式進行比較，具體步驟如下：
用戶自定義比較器類，實現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;
class Card {
public int rank; // 數值
public String suit; // 花色
public Card(int rank, String suit) {
this.rank = rank;
this.suit = suit;
}
}
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 包中的泛型接口類，使用時必須導入對應的包。
集合框架中的PriorityQueue底層使用堆結構，因此其內部的元素必須要能夠比大小，PriorityQueue采用了：Comparble和Comparator兩種方式。
Comparble是默認的內部比較方式，如果用戶插入自定義類型對象時，該類對象必須要實現Comparble接口，并覆寫compareTo方法
用戶也可以選擇使用比較器對象，如果用戶插入自定義類型對象時，必須要提供一個比較器類，讓該類實現Comparator接口并覆寫compare方法。
// JDK中PriorityQueue的實現：
public class PriorityQueue<E> extends AbstractQueue<E>
implements java.io.Serializable {
// ...
// 默認容量
private static final int DEFAULT_INITIAL_CAPACITY = 11;
// 內部定義的比較器對象，用來接收用戶實例化PriorityQueue對象時提供的比較器對象
private final Comparator<? super E> comparator;
// 用戶如果沒有提供比較器對象，使用默認的內部比較，將comparator置為null
public PriorityQueue() {
this(DEFAULT_INITIAL_CAPACITY, null);
}
// 如果用戶提供了比較器，采用用戶提供的比較器進行比較
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;
}
// ...
// 向上調整：
// 如果用戶沒有提供比較器對象，采用Comparable進行比較
// 否則使用用戶提供的比較器對象進行比較
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;
}
// 使用用戶提供的比較器對象進行比較
@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;
}
}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;
}
}
// 假設：創建的是小堆----泛型實現
public class MyPriorityQueue<E> {
private Object[] hp;
private int size = 0;
private Comparator<? super E> comparator = null;
// java8中：優先級隊列的默認容量是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;
}
// 按照指定容量設置大小
public MyPriorityQueue(int capacity) {
capacity = capacity < 1 ? 11 : capacity;
hp = new Object[capacity];
size = 0;
}
// 注意：沒有此接口，給學生強調清楚
// java8中：可以將一個集合中的元素直接放到優先級隊列中
public MyPriorityQueue(E[] array){
// 將數組中的元素放到優先級隊列底層的容器中
hp = Arrays.copyOf(array, array.length);
size = hp.length;
// 對hp中的元素進行調整
// 找到倒數第一個非葉子節點
for(int root = ((size-2)>>1); root >= 0; root--){
shiftDown(root);
}
}
// 插入元素
public void offer(E val){
// 先檢測是否需要擴容
grow();
// 將元素放在最后位置，然后向上調整
hp[size] = val;
size++;
shiftUp(size-1);
}
// 刪除元素: 刪除堆頂元素
public void poll(){
if(isEmpty()){
return;
}
// 將堆頂元素與堆中最后一個元素進行交換
swap((E[])hp, 0, size-1);
// 刪除最后一個元素
size--;
// 將堆頂元素向下調整
shiftDown(0);
}
public int size(){
return size;
}
public E peek(){
return (E)hp[0];
}
boolean isEmpty(){
return 0 == size;
}
// 向下調整
private void shiftDown(int parent){
if(null == comparator){
shiftDownWithcompareTo(parent);
}
else{
shiftDownWithComparetor(parent);
}
}
// 使用比較器比較
private void shiftDownWithComparetor(int parent){
// child作用：標記最小的孩子
// 因為堆是一個完全二叉樹，而完全二叉樹可能有左沒有有
// 因此：默認情況下，讓child標記左孩子
int child = parent * 2 + 1;
// while循環條件可以一直保證parent左孩子存在，但是不能保證parent的右孩子存在
while(child < size)
{
// 找parent的兩個孩子中最小的孩子，用child進行標記
// 注意：parent的右孩子可能不存在
// 調用比較器來進行比較
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);
// 小的元素往下移動，可能導致parent的子樹不滿足堆的性質
// 因此：需要繼續向下調整
parent = child;
child = child*2 + 1;
}
else{
return;
}
}
}
// 使用compareTo比較
private void shiftDownWithcompareTo(int parent){
// child作用：標記最小的孩子
// 因為堆是一個完全二叉樹，而完全二叉樹可能有左沒有有
// 因此：默認情況下，讓child標記左孩子
int child = parent * 2 + 1;
// while循環條件可以一直保證parent左孩子存在，但是不能保證parent的右孩子存在
while(child < size)
{
// 找parent的兩個孩子中最小的孩子，用child進行標記
// 注意：parent的右孩子可能不存在
// 向上轉型，因為E的對象都實現了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);
// 小的元素往下移動，可能導致parent的子樹不滿足堆的性質
// 因此：需要繼續向下調整
parent = child;
child = child*2 + 1;
}
else{
return;
}
}
}
// 向上調整
void shiftUp(int child){
if(null == comparator){
shiftUpWithCompareTo(child);
}
else{
shiftUpWithComparetor(child);
}
}
void shiftUpWithComparetor(int child){
// 獲取孩子節點的雙親
int parent = ((child-1)>>1);
while(0 != child){
// 如果孩子比雙親還小，則不滿足小堆的性質，交換
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){
// 獲取孩子節點的雙親
int parent = ((child-1)>>1);
while(0 != child){
// 如果孩子比雙親還小，則不滿足小堆的性質，交換
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;
}
// 仿照JDK8中的擴容方式，注意還是有點點的區別，具體可以參考源代碼
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};
// 小堆---采用比較器創建小堆
MyPriorityQueue<Integer> mq1 = new MyPriorityQueue(new LessIntComp());
for(int e : arr){
mq1.offer(e);
}
// 大堆---采用比較器創建大堆
MyPriorityQueue<Integer> mq2 = new MyPriorityQueue(new GreaterIntComp());
for(int e : arr){
mq2.offer(e);
}
// 小堆--采用CompareTo比較創建小堆
MyPriorityQueue<Integer> mq3 = new MyPriorityQueue();
for(int e : arr){
mq3.offer(e);
}
}
}到此，關于“java中各種對象的比較方法是什么”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
