【Java SE】对象的比较

基本类型的比较

Java中的基本类型可以直接通过比较运算符(>,<,>=,<=,==,!=)进行比较:

public class Test {
    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 Test {
    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指向的是同一个对象
    }
}

运行结果如下:

自定义类型能使用==是因为自定义类型都会默认继承Object类,而Object类中提供了equal方法,而==默认情况下调用的就是equal方法,但是equal方法的较规则是:没有比较引用变量引用对象的内容,而是直接比较引用变量的地址:

既然使用比较运算符比较的不是对象的内容,那我们应该怎么比较对象的内容呢?我们可以通过重写equals,comparable接口类和比较器进行比较。

1.重写equals

自定义类型都会默认继承Object类,而Object类中提供了equal方法。

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 obj) {
        // 如果obj是自己
        if (this == obj) {
            return true;
        }
        // o如果是null对象,或者o不是Card的子类
        if (obj == null || obj instanceof Card) {
            return false;
        }
        Card o = (Card)obj;
        //基本类型rank用==比较,引用类型用equals比较
        return this.rank == o.rank && suit.equals(obj);
    }
}

public class Test {
    public static void main(String[] args) {
        Card c1 = new Card(1, "♠");
        Card c2 = new Card(2, "♠");
        Card c3 = c1;
        System.out.println(c1.equals(c2));
        System.out.println(c1.equals(c3));
    }
}

运行结果如下:

重写equals方法虽然能比较对象的大小,但返回的是正负,如果想要按照大于小于的方式进行比较需要用到后面两种方法。

2.Comparable接口类

Comparabl e是JDK提供的泛型的比较接口类, java.lang 中的接口类,可以直接使用。
CompareTo的 返回值 :
1.< 0: 表示 o1 指向的对象小于 o2 指向的对象;
2.== 0: 表示 o1 指向的对象等于 o2 指向的对象;
3.> 0: 表示 o1 指向的对象等于 o2 指向的对象;
对于自定义类型,如果要想按照大小与方式进行比较时,实现 Comparble接口 重写 compareTo 方法即可:
class Card implements Comparable<Card> {
    public int rank; // 数值
    public 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 class Test {
    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 比较大
    }
}

运行结果如下:

3.比较器比较

Comparator java.util 包中的泛型接口类,使用时必须导入对应的包。
compare返回值 :
1. < 0: 表示 o1 指向的对象小于 o2 指向的对象;
2. == 0: 表示 o1 指向的对象等于 o2 指向的对象;
3. > 0: 表示 o1 指向的对象等于 o2 指向的对象;
使用比较器比较需要我们自定义比较器类:实现 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> {
    @Override
    public int compare(Card o1, Card o2) {
        //是自己,返回0
        if (o1 == o2) {
            return 0;
        }
        //o2没牌最小,返回-1
        if (o1 == null) {
            return -1;
        }
        //自己没牌,返回1
        if (o2 == null) {
            return 1;
        }
        //根据数值比较,不管花色
        return o1.rank - o2.rank;
    }
}

public class Test {
    public static void main(String[] args){
        Card p = new Card(1, "♠");
        Card q = new Card(2, "♠");
        Card o = new Card(1, "♠");
        // 定义比较器对象
        CardComparator cardComparator = new CardComparator();
        // 使用比较器对象进行比较
        System.out.println(cardComparator.compare(p, o)); // == 0,表示牌相等
        System.out.println(cardComparator.compare(p, q)); // < 0,表示 p 比较小
        System.out.println(cardComparator.compare(q, p)); // > 0,表示 q 比较大
    }
}

三种方式的比较

重写的方法描述
Object.equals()
因为所有类都是继承自 Object 的,所以直接覆写即可,不过只能比较相等与否
Comparable.compareTo()
需要手动实现接口,侵入性比较强,但一旦实现,每次用该类都有顺序,属于内部顺序
Comparator.compare()
需要实现一个比较器对象,对待比较类的侵入性弱,但对算法代码实现侵入性强
  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

记得开心一点啊

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值