Java对象的比较

• 1.基本类型的比较
• 2.对象的比较
• • • 对象值相等比较
    • 对象大小的比较

在Java中基本类型的对象可以直接比较大小；

代码示例：

public class TestCompare {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        System.out.println(a==b); //false
        System.out.println(a>b);  //false
        System.out.println(a 
2.对象的比较 
对象值相等比较 
== & equals 区别
 
 
 
== 是用来比较对象的引用地址是否相同，而 equals 一般是用来比较对象的内容的； 但需要手动重写object 类中的 equals 方法；
 
 
“==” 比较：
 
    public class Card {
    String  rank;
    String suit;

    public Card(String rank,String suit){
        this.rank=rank;  //牌面值
        this.suit=suit; //花色
    }

    public static void main(String[] args) {
        Card c1=new Card("1","♠");
        Card c2=new Card("3","♠ ");
        Card c3=c1;
        System.out.println(c1==c2);//false
       // System.out.println(c1>c2); //编译报错
        System.out.println(c1==c3);//true

    }
}
  
 
从编译结果可以看出，Java 中的引用类型变量不能直接按照 > 或者 < 方式进行比较的；
 那可能会有疑问：为什么==就能够比较呢？
 
 
 
对于用户实现的自定义类型，都默认继承自Object类，而 Object 类中提供了 equals 方法，而 == 默认情况下调用的就是 equals 方法；
 
 
equals 比较：
 
public static void main(String[] args) {
        Card c1=new Card("1","♠");
        Card c2=new Card("3","♠ ");
        Card c3=c1;
        System.out.println(c1.equals(c2));//false
        System.out.println(c1.equals(c3));//true

    }

 
结果跟上面是一样的，那是因为基类中的 equals 方法也是直接比较两个引用变量的地址是否一样~~，并没有比较内容是否相等，要比较内容还是需要手动重写的！！！
 
如下所示手动重写 equals：
 
 @Override
    public boolean equals(Object obj) {
        // 自己和自己比较
        if (this == obj) {
            return true;
        }
        // obj如果是null对象，或者obj不是Card的子类
        if (obj == null || !(obj instanceof Card)) {
            return false;
        }
        Card c = (Card)obj; //向下调整
          return this.rank.equals(c.rank)
              && this.suit.equals(c.suit);
    }

 
注意：
 
 
当指向同一个对象，返回 true；
 
 
当传入的为 null，返回 false;
 
 
当传入的对象类型不是 Card，返回 false；
 
 
只有当传入的牌面值与花色相同时，就为true；
 
 
手动重写后再调用该方法，此时结果与上面结果就不一样了
 
public static void main(String[] args) {
        Card c1=new Card("3","♠");
        Card c2=new Card("3","♠");
        Card c3=c1;
        System.out.println(c1.equals(c2)); //true
        System.out.println(c1.equals(c3)); //true
    }
 
结果如下：
 
 因为只要传入的牌面值与花色相同时，就为true；
 
对象大小的比较 
 
 
方式一：定义一个类去实现 Comparble 接口，重写该类中的compareTo 方法。（需要改代码）
 
 
代码如下：
 
public class Card implements Comparable{
        int rank;
        String suit;

        public Card(int rank,String suit){
            this.rank=rank;  //牌面值
            this.suit=suit; //花色
        }

    @Override
    public int compareTo(Card o) {
        if (o == null) {
            return 1;
        }
        return this.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)); //-1,p小于q

        }
}
 
 
 
方式二：基于比较器的比较，用户自定义比较器的类，实现 Comparator 接口,并重写 compare 方法；（不需要改代码，但需要重写一个类）
 
 
代码如下：
 
package day20211109;

import java.util.Comparator;

public class Card {
        int rank;
        String suit;

        public Card(int rank,String suit){
            this.rank=rank;  //牌面值
            this.suit=suit; //花色
        }
}



public class CardComparator implements Comparator {
    @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)); // -1，表示 p 比较小
        System.out.println(cmptor.compare(q, p));//1,表示 q 比较小

    }
}

 
三者的区别：
 
 
思考：
 
既然 Comparble的 compareTo 和 Comparator中的compare均可以实现对象大小的比较，那为什么要设计两个呢？
 
 
 
对于大型项目移植时，不能更改其他程序猿写好的类，但还要实现对象的大小比较，该种情况下，我们可以写一个类来实现 Comparator接口，重写Comparator 中的 compare方法即可满足项目要求； 也就是说该种情况下基于比较器的对象的大小比较更适合一些；其他情况选择其一均可；
 
					
										


					

						
欢迎分享，转载请注明来源：内存溢出
原文地址: http://outofmemory.cn/zaji/5437565.html