Java对象的比较

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

1.基本类型的比较

在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<b); //true
     }
}

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<Card>{
        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<Card> {
    @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方法即可满足项目要求； 也就是说该种情况下基于比较器的对象的大小比较更适合一些；其他情况选择其一均可；