Java中的比较（== 和 equals、Comparable接口、Comparator比较器、Arrays.sort( )）

最新推荐文章于 2024-07-22 08:37:45 发布
最新推荐文章于 2024-07-22 08:37:45 发布
阅读量785 收藏 1
点赞数 1
文章标签： java 接口 object
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/char_m/article/details/106233582
版权

Java中的比较

什么是比较？

在计算机领域中，比较分为两种：
身份的比较
值的比较

而在Java中主要有**三种比较方式：**
Object.equals
Comparable
Comparator

比较相等

== 和 equals

1） == ：比较对象身份，比较的是两个引用中保存的地址的值（判断引用中存的地址是不是相同）
p == q 表示的是 p 和 q 两个引用指向同一个对象

2） equals：
p.equals(q) 表示 p 指向的对象和 q 指向的对象是否是值语义（被赋予的值）相等的，我们平时比较String类型的时候其实也是进行了重写，是利用Comparable接口。
在这里插入图片描述

public class Card {
    public int rank; // 数值
    public String suit; // 花色

    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
 
    public static void main(String[] args) {
        Card card1 = new Card(1,"♥");
        Card card2 = new Card(1,"♥");
        Card o = card1;

        System.out.println(card1 == o); //true
        System.out.println(card1 == card2); //false

        System.out.println(card1.equals(o));  //true
        System.out.println(card1.equals(card2)); //false
    }
}

equals会默认调用==来比较身份，所以我们在使用的时候可以手动重写equals实现按自定义规则比较
在这里插入图片描述
在这里插入图片描述
重写注意：
a）this 和 o 是不是相同身份
b）o 是不是为空（null）
c）o 和 this 是不是相同类型
d）对 o 进行强制类型转换
e）按照自定义规则比较
在这里插入图片描述

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;
        }
        if(o == null || !(o instanceof Card)){
            return false;
        }

        Card card = (Card)o;
        return rank == card.rank
                && suit.equals(card.suit);
    }

    public static void main(String[] args) {
        Card card1 = new Card(1,"♥");
        Card card2 = new Card(1,"♥");
        Card o = card1;

        System.out.println(card1 == o); //true
        System.out.println(card1 == card2); //false

        System.out.println(card1.equals(o));  //true
        System.out.println(card1.equals(card2)); //true
    }
}

比较不等

Javaz中不支持运算符重载，Java中的 < > <= >= 只能针对数字类型来使用，如果创建了两个对象来进行比较大小，就需要专门的方法来完成。

1）实现Comparable接口

重写compareTo方法：this 和 o之间的比较
在这里插入图片描述
在这里插入图片描述

public class Card implements Comparable<Card> {
    public String rank; // 数值
    public String suit; // 花色

    public Card(String rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public int compareTo(Card o) {
        //对this 和 o 进行比较
        //如果this < o ,返回 < 0
        //如果this > o ,返回 > 0
        //如果this 和 o 相等 ,返回 0
        //定义比较规则：扑克牌的点数进行比较
        int rank1 = this.convertRank();
        int rank2 = o.convertRank();
        return rank1 - rank2;
    }
    private int convertRank(){
        //把String类型的rank转成int值
        //2-10 =》2-10
        //J-A => 11-14
        if("A".equals(rank)){
            return 14;
        }
        if("K".equals(rank)){
            return 13;
        }
        if("Q".equals(rank)){
            return 12;
        }
        if("J".equals(rank)){
            return 11;
        }
        return Integer.parseInt(rank);
    }

    public static void main(String[] args) {
        Card card1 = new Card("1","♥");
        Card card2 = new Card("1","♥");
        Card card3 = new Card("A","♥");
        Card o = card1;

        System.out.println(card1.compareTo(card2)); // 0
        System.out.println(card1.compareTo(card3)); // -13   A定义为数字14 // 1-14=-13
    }
}

实例


import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Card implements Comparable<Card> {
    public String rank; // 数值
    public String suit; // 花色

    public Card(String rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    @Override
    public int compareTo(Card o) {
        //对this 和 o 进行比较
        //如果this < o ,返回 < 0
        //如果this > o ,返回 > 0
        //如果this 和 o 相等 ,返回 0
        //定义比较规则：扑克牌的点数进行比较
        int rank1 = this.convertRank();
        int rank2 = o.convertRank();
        return rank1 - rank2;//升序
        //return rank2 - rank1;//降序
    }
    private int convertRank(){
        //把String类型的rank转成int值
        //2-10 =》2-10
        //J-A => 11-14
        if("A".equals(rank)){
            return 14;
        }
        if("K".equals(rank)){
            return 13;
        }
        if("Q".equals(rank)){
            return 12;
        }
        if("J".equals(rank)){
            return 11;
        }
        return Integer.parseInt(rank);
    }

    @Override
    public String toString() {
        return "Card{" +
                "rank='" + rank + '\'' +
                ", suit='" + suit + '\'' +
                '}';
    }

    public static void main(String[] args) {
        Card card1 = new Card("1","♥");
        Card card2 = new Card("1","♥");
        Card card3 = new Card("A","♥");
        Card o = card1;

        System.out.println(card1.compareTo(card2)); // 0
        System.out.println(card1.compareTo(card3)); // -13   A定义为数字14 // 1-14=-13

        List<Card> cardList = new ArrayList<>();
        cardList.add(new Card("A","♥"));
        cardList.add(new Card("K","♥"));
        cardList.add(new Card("2","♥"));
        cardList.add(new Card("J","♥"));
        cardList.add(new Card("10","♥"));
        Collections.sort(cardList);
        System.out.println(cardList);
    }
}
结果：
0
-13

[Card{rank='2', suit='♥'}, 
Card{rank='10', suit='♥'},
 Card{rank='J', suit='♥'}, 
 Card{rank='K', suit='♥'}, 
 Card{rank='A', suit='♥'}]

2）实现Comparator比较器

重写compare方法
在这里插入图片描述
在这里插入图片描述

实例

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Card {
    public String rank; // 数值
    public String suit; // 花色

    public Card(String rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
    public int convertRank(){
        //把String类型的rank转成int值
        //2-10 =》2-10
        //J-A => 11-14
        if("A".equals(rank)){
            return 14;
        }
        if("K".equals(rank)){
            return 13;
        }
        if("Q".equals(rank)){
            return 12;
        }
        if("J".equals(rank)){
            return 11;
        }
        return Integer.parseInt(rank);
    }

    @Override
    public String toString() {
        return "Card{" +
                "rank='" + rank + '\'' +
                ", suit='" + suit + '\'' +
                '}';
    }
}
class CardComparator implements Comparator<Card> {
    @Override
    public int compare(Card o1, Card o2) {
        int rank1 = o1.convertRank();
        int rank2  = o2.convertRank();
        return rank1 - rank2;//根据数值升序
        //return rank2 - rank1;//根据数值降序
    }

    public static void main(String[] args) {
        List<Card> cardList = new ArrayList<>();
        cardList.add(new Card("A","♥"));
        cardList.add(new Card("K","♥"));
        cardList.add(new Card("2","♥"));
        cardList.add(new Card("J","♥"));
        cardList.add(new Card("10","♥"));
        Collections.sort(cardList,new CardComparator());
        System.out.println(cardList);
    }
}


 结果：
 [Card{rank='2', suit='♥'}, 
 Card{rank='10', suit='♥'}, 
 Card{rank='J', suit='♥'}, 
 Card{rank='K', suit='♥'}, 
 Card{rank='A', suit='♥'}]

3） Arrays.sort( )（拓展）

可以给Arrays.sort( )的第二个参数，传入排序的比较器，然后来规定排序方式
在这里插入图片描述

实例

import java.util.Arrays;
import java.util.Comparator;

public class Card {
    public String rank; // 数值
    public String suit; // 花色

    public Card(String rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }

    public int convertRank() {
        //把String类型的rank转成int值
        //2-10 =》2-10
        //J-A => 11-14
        if ("A".equals(rank)) {
            return 14;
        }
        if ("K".equals(rank)) {
            return 13;
        }
        if ("Q".equals(rank)) {
            return 12;
        }
        if ("J".equals(rank)) {
            return 11;
        }
        return Integer.parseInt(rank);
    }

    @Override
    public String toString() {
        return "Card{" +
                "rank='" + rank + '\'' +
                ", suit='" + suit + '\'' +
                '}';
    }
}
    class CardComparator implements Comparator<Card> {
        @Override
        public int compare(Card o1, Card o2) {
            int rank1 = o1.convertRank();
            int rank2  = o2.convertRank();
            return rank1 - rank2;//根据数值升序
            //return rank2 - rank1;//根据数值降序
        }
        public static void main(String[] args) {
            Card[] cards = new Card[3];
            cards[0] = new Card("A","♥");
            cards[1] = new Card("2","♥");
            cards[2] = new Card("J","♥");
            CardComparator cardComparator = new CardComparator();
            Arrays.sort(cards,cardComparator);
            System.out.println(Arrays.toString(cards));
        }
}

结果：
[Card{rank='2', suit='♥'}, Card{rank='J', suit='♥'}, Card{rank='A', suit='♥'}]

三种比较方法的比较

覆写的方法说明
Object.equals因为所有类都是继承自 Object 的，所以直接覆写即可，不过只能比较相等与否
Comparable.compareTo需要手动实现接口，侵入性比较强，但一旦实现，每次用该类都有顺序，属于内部顺序
Comparator.compare需要实现一个比较器对象，对待比较类的侵入性弱，但对算法代码实现侵入性强

和Java集合框架的配合

1、使用 contains 类似的方法，内部基本在调用元素的 equals 方法，所以要求元素重写过 equals 方法
2、使用 HashMap，key 的比较内部会调用 equals 方法，所以要求元素重写过 equals 方法
3、使用排序相关方法，内部需要进行比较，所以或者选择实现Comparable 或者传入一个 Comparator
4、使用 TreeMap，key 需要进行大小比较，所以或者选择实现 Comparable 或者传入一个 Comparator

要不一起ci个饭
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java中的比较器：Comparable接口和Comparator接口
weixin_44585687的博客
01-14 329
1.java比较器的使用背景： Java中的对象，正常情况下，只能进行比较： == 或！= ，不能使用 > 或者 < 的 但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。 如何实现？使用两个接口中的任何一个：Comparable 或 Comparator 2.自然排序：使用Comparable接口 2.1说明 1.像String、包装类等实现了Comparable接口，重写compareTo()方法，给出了比较两个对象大小 2.像String、包装类重写了compa
Comparable接口和Comparator接口
桐花思雨
12-06 714
目录前言`Comparable` 接口 前言 在实际应用中，我们往往有需要 比较两个自定义对象 大小的地方。而这些自定义对象的比较，就不像简单的整型数据那么简单，它们往往包含有许多的属性，我们一般都是根据这些属性对自定义对象进行比较的。所以 Java 中要 比较对象的大小 或者要 对对象的集合 进行排序，需要通过比较这些对象的某些属性的大小来确定它们之间的大小关系 一般 Java 中通过接口来实现两个对象的比较，比较常用就是 Comparable 接口和Comparator 接口 Comparable 接口
Java笔记：equals&Comparable接口&比较器Comparator
长不大的大灰狼
02-19 444
1 Object.equals ==和equals: p==q表示的是p和q两个引用指向同一个对象。 p.equals(q)表示p和q指向的对象值是否相等。 1 覆写equals()方法来实现对象间的比较(是否相等) Card类覆写equals方法实现牌类对象的比较： public class Card { public int rank; // 数值 public String suit...
Comparable Comparator equals
weixin_33887443的博客
02-03 215
为了让类的对象间可以排序，通常有两种方法——Comparable<T> 与 Comparator<T>。 为了判断两个对象是否相等与Set中去重，通常重写根类的equals()方法。 为了逻辑一致：强烈建议重写comparableTo()后也重写equals()方法。 Comparable泛型接口 int java.lang.C...
【Java】Java数组排序详解：全面掌握Arrays.sort()的几种用法
最新发布
科技改变人类，技术成就未来
07-22 1664
在 Java 开发中，java.util.Arrays 类提供了许多实用工具，用于操作数组。其中，Arrays.sort() 方法是对数组进行排序的常用方法。本文将详细介绍 Arrays.sort() 的不同用法，包括基本类型数组、对象数组、多维数组和自定义比较器的排序。
[Java] - Java对象的比较,equals,Comparable,Comparator
weixin_65941860的博客
06-01 284
Java比较方法，equals，Comparator，Comparable
Java比较器之equals、comparable、comparator
qq_45283185的博客
09-27 465
在Java中，基本类型的对象可以直接比较，而自定义类型，默认是用equal方法，但是它没有比较引用变量引用对象的内容，而是直接比较引用变量的地址，本文记录了解决该问题的几种方法。
Java Array 修改比较器并用Arrays.sort排序
PearlyWave的博客
04-10 203
import java.util.*; public class Main { private static Scanner in; private static int number; public static void main(String[] args) { int maxY = -1; int maxTheta = 0; in = new Scanner(System.in); // Map<Integ
对比Java中的Comparable排序接口和Comparator比较器接口
09-02
在Java编程语言中，Comparable和Comparator接口用于对对象进行比较和排序。这两个接口在很多情况下都能派上用场，但它们的应用场景和实现方式有所不同。 首先，Comparable接口是排序接口，意味着一个类如果实现了...
详解Java中Comparable和Comparator接口的区别
08-29
Java 中的 Comparable 和 Comparator 接口详解 Java 中的 Comparable 和 Comparator 接口都是用于比较和排序的，但是它们之间存在着一些关键的区别。Comparable 是一个排序接口，若一个类实现了 Comparable 接口，...
python中迭代对象_一篇文章弄懂Python中的可迭代对象、迭代器和生成器
weixin_39613089的博客
12-04 209
我们都知道，序列可以迭代。但是，你知道为什么吗？ 本文来探讨一下迭代背后的原理。序列可以迭代的原因：iter 函数。解释器需要迭代对象 x 时，会自动调用 iter(x)。内置的 iter 函数有以下作用：(1) 检查对象是否实现了 iter 方法，如果实现了就调用它，获取一个迭代器。(2) 如果没有实现 iter 方法，但是实现了 getitem 方法，而且其参数是从零开始的索引，Python ...
java对象的比较(Comparble、equals、Comparator)
m0_73594607的博客
05-06 395
超详细的Java对象比较讲解！
Java中compare方法
qq_65848454的博客
07-09 6135
【代码】Java中compare方法。
ｊａｖａ　ｃｏｍｐａｒｅ函数
h_666666的博客
02-25 4358
这个以前我一直不太清楚，关于返回１　－１　０　的问题，特别是自定义函数不知道怎么写 然后看到了一句金句：当前对象与后一个对象进行比较，如果比较结果为1进行交换，其他不进行交换。this就是当前对象，另一个就是后一个对象。 原文链接：http://www.cnblogs.com/gengaixue/p/6928654.html －１不交换，为１是交换　！！！ 就因为这个错了好多　额。，， ...
【Java 对象的比较】equals，Comparable,Comparator三种比较方式
Wisk1019的博客
04-11 279
【Java 对象的比较】equals，Comparable,Comparator三种比较方式
java可比较的和比较器的区别_java-比较器并与equals相符：如何？ (最佳实...
weixin_36125588的博客
03-08 66
我知道,为了符合Java的Collections合同(并避免发生意外行为),任何提供的Comparator都应与equals保持一致.假设我有这样的人：class Person {private String name;private String surname;private int age;public Person(String name, String surname, int age)...
==和equals区别&comparable和comparator区别
WS_HSY90的博客
12-05 809
首先equals和== 最大的区别是一个是方法一个是运算符,对于基本数据类型如byte,short,char,int,float,double,long,boolean等之间的比较用==比较的是值是否相等,对于引用数据类型如果用==比较的话,只会比较他们内存中存放的地址,除非是同一个new出来的,不然比较结果为false. 然后equals方法,当我们定义类时是默认继承object类的,因此在o
比较（"=="、"equals"、Comparable、Comparator）
star9523的博客
04-17 348
对象值相等的比较 “==”和equals p == q 表示的是 p 和 q 两个引用指向同一个对象 p.equals(q) 表示 p 指向的对象 和 q 指向的 对象是否是值语义相等的 equals如果没有手动重写，默认执行的就是Object版本中的equals。比较规则和“==”一样 结果 手动重写equals 运行结果 有了下面这个条件，则可以使 String str = null；...
Java排序接口详解：Comparable与Comparator的区别与使用
"Java 中的 Comparable 和 Comparator 是两种在编程中用于对象排序的关键接口，它们在 Java 应用程序中有着广泛的应用。Comparable 接口主要用于实现类的自然排序，而 Comparator 接口则用于自定义排序规则。本文将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值