JAVA对象的比较

最新推荐文章于 2023-03-05 17:10:45 发布
最新推荐文章于 2023-03-05 17:10:45 发布
阅读量163 收藏
点赞数
文章标签： java 接口
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45309293/article/details/109694605
版权

一、基本类型的比较
在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);
    }
}

结果如下：
在这里插入图片描述
二、对象的比较

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(1, "♠");
        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);
}

没有比较引用变量引用对象的内容，而是直接比较引用变量的地址，但是在有些情况下就会有些不符合常理。比如：我们常理认为c1是等于c2的，但是由于计算机比较的是地址结果就是不等于，这就是不符合常理。那么我们如何来让equals()方法来按照我们的意思来比较呢？我们需要重写该方法。
1.基于Object类的equals()方法的比较：
在自己定义的类中重写该方法

class Card {
    public int rank; // 数值
    public String suit; // 花色
    public Card(int rank, String suit) {
        this.rank = rank;
        this.suit = suit;
    }
    @Override//重写Object类的方法
    public boolean equals(Object o){
        if (this == o){
            return true;
        }
        if (o == null || !(o instanceof Card)){
            return false;
        }
        if (this.rank == ((Card) o).rank){
            return true;
        }
        return false;
    }
}
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(c3.equals(c1));
        System.out.println(c2.equals(c1));
    }
}

equals()方法只能比较对象是否相等，那么对象大小如何比较呢？
2.基于Comparble接口类的比较
Comparble是JDK提供的泛型的比较接口类，源码实现具体如下：

public interface Comparable<E> {
// 返回值:
// < 0: 表示 this 指向的对象小于 o 指向的对象
// == 0: 表示 this 指向的对象等于 o 指向的对象
// > 0: 表示 this 指向的对象大于 o 指向的对象
     int compareTo(E o);
}

对用用户自定义类型，如果要想按照大小与方式进行比较时：在定义类时，实现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) {
        return this.rank - o.rank;
    }
}
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.compareTo(c2));
        System.out.println(c1.compareTo(c3));
    }
}

在这里插入图片描述
结果< 0: 表示 this 指向的对象小于 o 指向的对象
结果== 0: 表示 this 指向的对象等于 o 指向的对象
结果> 0: 表示 this 指向的对象大于 o 指向的对象
3.基于比较器比较
比较器Comparator具体源码如下：

public interface Comparator<T> {
// 返回值:
// < 0: 表示 o1 指向的对象小于 o2 指向的对象
// == 0: 表示 o1 指向的对象等于 o2 指向的对象
// > 0: 表示 o1 指向的对象大于 o2 指向的对象
int compare(T o1, T o2);
}

用户自定义比较器类，实现Comparator接口进行对象比较：

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) {
        if (o1 == null){
            return -1;
        }
        if (o2 == null){
            return 1;
        }
        return o1.rank - o2.rank;
    }
}
public class Test {
    public static void main(String[] args) {
        Card c1 = new Card(1, "♠");
        Card c2 = new Card(2, "♠");
        Card c3 = c1;
        CardComparator cardComparator = new CardComparator();
        System.out.println(cardComparator.compare(c1,c2));
        System.out.println(cardComparator.compare(c1,c3));
    }
}

在这里插入图片描述
Comparator是java.util 包中的泛型接口类，使用时必须导入对应的包。
结果< 0: 表示 c1小于 c2
结果== 0: 表示 c1等于 c2
结果> 0: 表示 c1大于c2
三、集合框架类型中PriorityQueue的比较方式
集合框架中的PriorityQueue底层使用堆结构，因此其内部的元素必须要能够比大小，PriorityQueue采用了：
Comparble和Comparator两种方式。

  1. Comparble是默认的内部比较方式，如果用户插入自定义类型对象时，该类对象必须要实现Comparble接
    口，并覆写compareTo方法
  2. 用户也可以选择使用比较器对象，如果用户插入自定义类型对象时，必须要提供一个比较器类，让该类实现
    Comparator接口并覆写compare方法。
    写法1：
package VI;

import java.util.Comparator;
import java.util.PriorityQueue;

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

    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
}
class CardComparator implements Comparator<Card> {

    @Override
    public int compare(Card o1, Card o2) {
        return o1.rank - o2.rank;
    }
}
public class Test {
    public static void main(String[] args) {
        Card c1 = new Card(5,"♠");
        Card c2 = new Card(6,"♠");
        Card c3 = new Card(1,"♠");
        Card c4 = new Card(3,"♠");
        Card c5 = new Card(2,"♠");
        CardComparator cardComparator = new CardComparator();
        PriorityQueue<Card> priorityQueue = new PriorityQueue<>(cardComparator);
        priorityQueue.offer(c1);
        priorityQueue.offer(c2);
        priorityQueue.offer(c3);
        priorityQueue.offer(c4);
        priorityQueue.offer(c5);
        System.out.println(priorityQueue);
    }
}

结果：
在这里插入图片描述

写法2：

package VI;

import java.util.Comparator;
import java.util.PriorityQueue;

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

    @Override
    public String toString() {
        return "Card{" +
                "rank=" + rank +
                ", suit='" + suit + '\'' +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        Card c1 = new Card(5,"♠");
        Card c2 = new Card(6,"♠");
        Card c3 = new Card(1,"♠");
        Card c4 = new Card(3,"♠");
        Card c5 = new Card(2,"♠");

        PriorityQueue<Card> priorityQueue = new PriorityQueue<>(new Comparator<Card>() {
            @Override
            public int compare(Card o1, Card o2) {
                return o1.rank - o2.rank;
            }
        });
        priorityQueue.offer(c1);
        priorityQueue.offer(c2);
        priorityQueue.offer(c3);
        priorityQueue.offer(c4);
        priorityQueue.offer(c5);
        System.out.println(priorityQueue);
    }
}

在这里插入图片描述
为什么o1-o2是建立一个小根堆，o2-o1是建立大根堆？
在比较器接口中底层有这么一句源码：

 for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--)
                    swap(dest, j, j-1);

这句源码意思是，如果compare()返回值大于0，则交换dest[j - 1]和dest[j],二者分别对应o1,o2。

这样看来当compare()返回o1-o2时，结果大于0，说明o1>o2，此时会发生交换，于是就成了升序，也就是小堆。

相反如果返回o2-o1，结果就是小于0，并不会发生交换，于是就是降序，也就是大堆。

玄月望二
关注
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
Java比较两个对象是否相同并获取值不同的属性
m0_71777195的博客
10-08 3045
最近项目中要加操作日志，同时要把用户修改了那些字段记录下来，在更新的时候就需要比较之前的数据和现在的数据有哪些不同，这么多类一个一个的比较就太麻烦了，所以打算写一个工具类。主要思想还是通过反射获取类的属性的getter方法，调用getter方法获取值并比较是否相同，相同就忽略不同就返回属性信息，方法都不复杂，主要是利用反射思想。代码如下： 定义一个类保存比较后的返回值信息。能力一般，水平有限，如有错误，请多指出。2、跟另一个对象的所有属性值比较。1、获取对象的属性属性值。
Java - 对象的比较
最新发布
ryy1999的博客
03-05 2604
默认情况下调用的就是equal方法，但是该方法的比较规则是：没有比较引用变量引用对象的内容，而是直接比较引用变量的地址，但有些情况下该种比较就不符合题意。
Java对象比较
yamikaze的博客
12-23 474
对于Java的对象比较，聊一下个人的看法。 我们知道Java里面比较对象相等，有2种方式 ，== 或者 equals方法。 equals比较方式比较简单，在这儿不做过多说明，主要对==方式进行说明。 1、基本类型比较 Java的8大基本类型可以直接使用==进行比较，可以认为这儿的基本类型的比较是值比较。 例如下面的代码块: int i = 1; int j = 2; Syste...
java对象的比较
weixin_51970219的博客
01-08 2600
java对象的比较1.元素的比较1.1基本类型比较1.2对象的比较2.对象的比较2.1覆写基类的equal2.2基于Comparable接口类的比较2.3Comparator比较器接口2.4三种方式比较 1.元素的比较 1.1基本类型比较 1.在java中，基本数据类型的对象可以直接比较大小。 2.示例： package compare; public class Testcompare { public static void main(String[] args) { int
java比较两段json不同工具类（两个同一类型的java对象比较也推荐转成JSON再进行比较）
pipi_7的博客
04-12 5819
import java.util.Iterator;import net.sf.json.JSONArray; import net.sf.json.JSONObject;public class JsonDiff { // private static StringBuilder sb = new StringBuilder(); @SuppressWarnings("unchecked"
Java中比较自定义类的两个对象的内容是否相等
渔舟的博客
08-31 3624
重写equals方法练习。
java 比较对象_Java 对象比较
weixin_29669899的博客
02-20 1003
1.看下面的代码，输出什么呢？Integer n1 = new Integer(47);Integer n2 = new Integer(47);System.out.println(n1==n2);答案是： 输出 false。为什么n1和n2的值相同，用“==”比较结果却是false呢？因为“==”比较的不是对象的值，而是对象的引用。而n1和n2引用两个不同的对象。2.如果想比较两个对象的实际内...
java 对象比较
LIUXING_SUNNY的博客
03-19 387
对象比较主要是 hashcode 与equels 这两个方法 ，其中hashcode 与equels 方法 可由 myeclipse 自动生成。     如果对象要保存在 HashSet 或 HashMap 中，它们的 equals 相等，那么，它们的 hashcode     值就必须相等。     如果不是要保存在HashSet或HashMap，则与hashcode没有什么关
Java对象的比较
哈哈哈哈的博客
11-04 1648
Java中的对象比较
Java 对象的比较
qq_44773719的博客
11-29 109
1.关于对象值相等的比较： p == q 表示的是两个引用指向同一个对象 p.equals(q) 默认情况下也是比较身份。 示例： class Card1 { public String suit; public int rank; public Card1(String suit, int rank) { this.suit = suit; ...
java各种object比较DAO、DTO（待更新）
杂物堆
11-10 689
数据传输对象(Data Transfer Object)，是一种设计模式之间传输数据的软件应用系统。数据传输目标往往是数据访问对象从数据库中检索数据。数据传输对象与数据交互对象或数据访问对象之间的差异是一个以不具有任何行为除了存储和检索的数据（访问和存取器）。我的理解是，把数据库中某个table的结构映射成java类。（感觉和python的orm差不多）定义的这个接口有啥用啊？是为了别的类似的类可以继承吗？一个典型的DAO 模式主要由以下几部分组成。
Java 对象比较
Java软贱攻城狮
04-20 210
范例1:class Info{ private String msg="Hello"; public void print() { System.out.println("msg="+msg); } public void fun(Info temp) { temp.msg="修改的内容"; } } public class Demo { public static void ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值