精华内容
下载资源
问答
  • 我们知道所有的对象都拥有标识(内存地址)和状态(数据),同时“==”比较两个对象的的内存地址,所以说使用Objectequals()方法是比较两个对象的内存地址是否相等,即若object1.equals(object2)为true,则表示equals1...
    我们知道所有的对象都拥有标识(内存地址)和状态(数据),同时“==”比较两个对象的的内存地址,所以说使用Object的equals()方法是比较两个对象的内存地址是否相等,即若object1.equals(object2)为true,则表示equals1和equals2实际上是引用同一个对象。虽然有时候Object的equals()方法可以满足我们一些基本的要求,但是我们必须要清楚我们很大部分时间都是进行两个对象的比较,这个时候Object的equals()方法就不可以了。
     定义Person类,属性有name age sex  避免有重复数据录入我们特此重写object类中的equals方法。
    

    重写代码如下:

    public boolean equals(Object obj) {
            //this代表本类
            if (this == obj) {
                return true;
            }
            // 判断两个对象属性是不是相同
            if (obj instanceof Person) {
                //obj强制转换Person类
                Person p = (Person) obj;
                //比较  == int型比较 
                if ((this.name.equals(p.name)) && (this.age == p.age)&& (this.sex.equals(p.sex))) {
                    return true;
                }
            }
            return false;
        }

    在Java规范中,它对equals()方法的使用必须要遵循如下几个规则:

      equals 方法在非空对象引用上实现相等关系:
    
     1、自反性:对于任何非空引用值 x,x.equals(x) 都应返回 true。
    
     2、对称性:对于任何非空引用值 x 和 y,当且仅当 y.equals(x) 返回 true 时,x.equals(y) 才应返回 true。
    
      3、传递性:对于任何非空引用值 x、y 和 z,如果 x.equals(y) 返回 true,并且 y.equals(z) 返回 true,那么 x.equals(z) 应返回 true。
    
      4、一致性:对于任何非空引用值 x 和 y,多次调用 x.equals(y) 始终返回 true 或始终返回 false,前提是对象上 equals 比较中所用的信息没有被修改。
    
     5、 对于任何非空引用值 x,x.equals(null) 都应返回 false。  
    
      对于上面几个规则,我们在使用的过程中最好遵守,否则会出现意想不到的错误。
    
      在java中进行比较,我们需要根据比较的类型来选择合适的比较方式:
    
     1) 对象域,使用equals方法 。 
       2) 类型安全的枚举,使用equals或== 。 
      3) 可能为null的对象域 : 使用 == 和 equals 。 
     4) 数组域 : 使用 Arrays.equals 。 
     5) 除float和double外的原始数据类型 : 使用 == 。 
     6) float类型: 使用Float.foatToIntBits转换成int类型,然后使用==。  
      7) double类型: 使用Double.doubleToLongBit转换成long类型,然后使用==。
    

    至于6)、7)为什么需要进行转换,我们可以参考他们相应封装类的equals()方法,下面的是Float类的:

    public boolean equals(Object obj) {
        return (obj instanceof Float)
               && (floatToIntBits(((Float)obj).value) == floatToIntBits(value));
        }

    原因:
    然而,有两个例外:如果f1和f2都代表自由浮动。南,那么等于方法返回真的,即使Float.NaN = = Float.NaN假的有价值。
    如果<代码> f1代表+ 0.0 ff2代表-0.0 f,或副平等的测试值假的,即使0.0 f = = -0.0 f有真正的价值。

    展开全文
  • 重写Object类equals方法 Object类equals方法默认比较的是两个对象的地址值,没有意义 所以我们需要重写equals方法,比较两个对象的属性值(name,age) 对象的属性值一样好,返回true,否则返回false 问题: 隐含着...

    重写Object类的equals方法

    Object类的equals方法默认比较的是两个对象的地址值,没有意义
    所以我们需要重写equals方法,比较两个对象的属性值(name,age)
    对象的属性值一样好,返回true,否则返回false
    问题:
    隐含着一个多态
    Object obj = p2 = = new Person(“古力娜扎”,29);

    多态弊端:无法使用子类特有的内容(属性,方法)
    解决:可以使用向下转型(强转)把Object类型转换为Person

    代码01

    package com.object.demo01;
    
    import java.util.Objects;
    
    public class Person {
        private String name;
        private int age;
    
        public Person() {
        }
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    /*
          Object类的equals方法默认比较的是两个对象的地址值,没有意义
          所以我们需要重写equals方法,比较两个对象的属性值(name,age)
              对象的属性值一样好,返回true,否则返回false
              问题:
              隐含着一个多态
              Object obj = p2 = = new Person("古力娜扎",29);
              多态弊端:无法使用子类特有的内容(属性,方法)
              解决:可以使用向下转型(强转)把Object类型转换为Person
     */
        @Override
        public boolean equals(Object o) {
             //增加一个判断,传递的参数obj是this本身,直接返回true,提高程序效率
            if (o==this){
                return true;
            }
    
            //增加一个判断,传递的参数o是null,直接返回false  提供程序的效率
               if (o==null){
                   return false;
               }
    
            //增加一个判断,是Person类型再转换,防止类型转换异常,ClassCastException
    
            if (o instanceof Person){
                //使用向下转型(强转)把Object类型转换为Person
                Person p = (Person)o;
                //比较两个对象的属性,一个是调用方法的this(p1),一个就是p(o=p2)
                boolean b = this.name.equals(p.name)&&this.age==p.age;
                return b;
            }
            //不是Person类型直接返回false
            return false;
        }
    
     //alt +insert 设置
    //    @Override
    //    public boolean equals(Object o) {
    //        if (this == o) return true;
    //        //getClass() != o.getClass()使用反射机制,判断o是否为Person类型 等效于 哦instance of Person
    //        if (o == null || getClass() != o.getClass()) return false;
    //        Person person = (Person) o;
    //        return age == person.age &&
    //                Objects.equals(name, person.name);
    //    }
    //
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    代码02

    package com.object.demo01;
    
    import java.util.Random;
    
    public class Demo02Equals {
    
        public static void main(String[] args) {
            Person p1 = new Person("迪丽热巴",29);
            Person p2 = new Person("迪丽热巴",29);
    //        Person p2 = new Person("古力娜扎",29);
            System.out.println("p1:"+p1);   //p1:com.object.demo01.Person@1540e19d
            System.out.println("p2:"+p2);   //p1:com.object.demo01.Person@1540e19d
    
            boolean b1 = p1.equals(p2);
            System.out.println(b1);  //false   | true
    
            Random r = new Random();
    
            boolean b2 = p1.equals(r);
            System.out.println(b2); //ClassCastException   |  false
    
            boolean b3 = p1.equals(null);
            System.out.println(b3); //false
    
            boolean b4 = p1.equals(p1);
            System.out.println(b4);  //true
        }
    }
    
    展开全文
  • 今天小编就为大家分享一篇关于关于Objectequals方法和hashCode方法判断的分析,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 详解Object类equals方法

    千次阅读 2017-02-15 16:09:20
    详解Object类equals方法

    值类型与引用类型

    众所周知,Java的数据类型分为两类,8种基本的数据类型(byte、short、int、long、float、double、char、boolean)和引用类型。基本数据类型通过对应的包装类与引用类型建立联系。与此同时,这两类数据的存储也不相同,基本数据类型,,也叫值类型,存放在栈内存当中,引用数据类型的变量在栈中仅仅存放引用类型变量的地址,其本身则存放在堆内存当中。

    Java中==与equals的区别

    ==操作比较的是两个变量的值,对于引用类型表示的是两个变量在堆中存储的地址是否相同,即栈中的内容是否相同。

    equals操作表示的两个变量是否是对同一个对象的引用,即堆中的内容是否相同,该方法继承自Java的根类Object。

    String类的equals方法源码解析

    Object类的equals方法:

    public boolean equals(Object obj) {
            return (this == obj);
        }
    
    String类的equals方法:

    public boolean equals(Object anObject) {
            if (this == anObject) {
                return true;
            }
            if (anObject instanceof String) {
                String anotherString = (String)anObject;
                int n = value.length;
                if (n == anotherString.value.length) {
                    char v1[] = value;
                    char v2[] = anotherString.value;
                    int i = 0;
                    while (n-- != 0) {
                        if (v1[i] != v2[i])
                            return false;
                        i++;
                    }
                    return true;
                }
            }
            return false;
        }

    结论:

    如果不重写equals方法,那么所有的类都自动继承Object类的equals方法

    当String类调用equals方法时,当二者在栈内存的内容时,直接判断为true;否则,判断该类是否是String的实例,然后进一步比较字符串每个字符是否相等

    测试用例

    public static void main(String[] args) {
            String str = new String("验证object类的tostrin方法");
            String arr = new String("验证object类的tostrin方法");
            System.out.println(str == arr);
            System.out.println(str.equals(arr));
            Person p1 = new Person(12,"peter");
            Person p2 = new Person(12,"peter");
            Person p3 = p1;
            System.out.println(p1.equals(p2));
            System.out.println(p1 == p2);
            System.out.println(p3.equals(p1));
            System.out.println(p3 == p1);
        }

    输出结果及分析:

    false:引用的名称不同,直接判断为false

    true:字符串的内容相同,判断为true

    false:调用Object类的equals方法,引用名称不同,判断为false

    false:根据“==”的规则直接判断为false

    true:两对象是相同的引用

    true:同上

    总结:

     1)对于==,如果作用于基本数据类型的变量,则直接比较其存储的 “值”是否相等;如果作用于引用类型的变量,则比较的是所指向的对象的地址

      2)equals方法(equals方法不能作用于基本数据类型的变量),如果没有对equals方法进行重写,则比较的是引用类型的变量所指向的对象的地址;诸如String、Date等类对equals方法进行了重写的,比较的是所指向的对象的内容。


    参考文献:Java核心技术,第九版

                   Java编程思想,第四版






    展开全文
  • Java重写object类equals方法

    千次阅读 2020-12-19 16:53:27
    Object类是所有的父类,它的equals方法自然会被所有继承,有一个子 String对equals方法进行了覆盖(重写),使其具有了新功能 2.Object类的equals()方法与==没区别 Java.lang.String重写了equals()方法,把...

    1.Object类的equals()方法:
    比较两个对象是否是同一个对象,equals() 方法比较两个对象,是判断两个对象引用指向的是同一个对象,即比较 2 个对象的内存地址是否相等。是则返回true
    Object类是所有类的父类,它的equals方法自然会被所有类继承,有一个子 类String对equals方法进行了覆盖(重写),使其具有了新功能


    2.Object类的equals()方法与==没区别
    Java.lang.String重写了equals()方法,把equals()方法的判断变为了判断其值
    当有特殊需求,如认为属性相同即为同一对象时,需要重写equals()
    在这里插入图片描述

    总结:
    1.基本数据类型数据值只能用
    2.对于引用数据类型,和Object的equals方法是一样的。(查看源码)
    由于String类对父类Object的equals方法的重写,导致equals与= =唯一的区别在于比较对象

    例题 :
    重写比较规则,判断两名学员(Student)是否为同一对象
    Student相关属性
    Id(学号)、name(姓名)、age(年龄)
    如果两名学员的学号以及姓名相同,则为同一对象

    在这里插入图片描述
    1 对 Student类进行封装 然后在里面重写equals方法
    方法代码:

    public class  Student {
        private  int id;
        private  String name;
        private  int age;
    
        @Override  //重写equals方法
        public boolean equals(Object obj) {
           if(obj instanceof Student){
               Student s1=(Student)obj;
               return this.id==s1.id&&this.name==s1.name&&this.age==s1.age;
           }else {
               System.out.println("错误");
               return false;
           }
        }
    
        public Student(int id, String name, int age) {
            this.id = id;
            this.name = name;
            this.age = age;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    测试类进行测试

     public static void main(String[] args) {
            Student s1 = new Student(1,"张三",18);
            Student s2 = new Student(1,"张三",18);
    
            Student s3 = new Student(1,"张三",18);
            Student s4 = new Student(1,"张三",20);
    
            System.out.println(s1.equals(s2));
    
            System.out.println(s3.equals(s4));
    
    
    
        }
    

    以上程序执行结果

    在这里插入图片描述

    展开全文
  • 在开始编写文章前,有几个问题需要思考一下: equals 和 hashCode 方法是什么? equals 方法具有哪些...在 Object 中,这个方法将判断两个对象是否具有相同的引用。如果两个对象具有相同的引用,它们一定是相...
  • 一,equals方法Object类中 public boolean equals(Object obj) {   return (this == obj);   }  内部也是使用“==”比较引用是否指向同一个对象。所以在不覆盖equals方法时,使用equals方法和==的...
  • Java中Object类equals方法

    千次阅读 2016-09-03 20:46:26
    所有都从Object类中继承了equals方法 Object类equals方法源代码如下: public boolean equals(Object obj) { return this == obj; } Object中的equals方法是直接判断this和obj本身的值是否相等,即用来...
  • 1. Object类 Object类是java中的一个特殊的,它是所有的父类。 如果一个没有使用extends关键字明确标识继承另外一个,那么...2.Object类equals方法的应用 由于所有都是由object衍生出来的,所以Obje...
  • 覆盖/重写Object类equals方法

    千次阅读 2018-07-22 19:53:43
    我们在写程序时,往往有时Java类库中的equals方法不能满足我们的需求。这时,就需要我们自己来定义equals方法。 在写自定义equals方法之前,我满先来看两个类库中已经写好的equals方法。 一、Object.equals() 很...
  • equals方法的签名:接受一个Object类型的对象obj作为参数. equal
  • Object类equals方法与hashcode方法分析 equals 源代码 public boolean equals(Object obj) { return (this == obj); } 概述 指示其他对象是否等同于这个对象。 equals方法在非空对象引用上实现等价...
  • Object类中的equals方法

    千次阅读 2019-06-15 08:56:45
    Demo01: ...* 因为Object是所有的顶级父类,所以我们根据创建的对象都可以使用equals方法 * Object类中equals源码: * public boolean equals(Object obj) { return (this == obj); } thi...
  • 一,equals方法的作用:检测一个对象是否等于另一个对象   1)比较两个基本类型的数据的值是否相等。这里是直接比较的值。【错误:基本数据类型没有equals方法】 mark:Java中的基本类型: int,4个字节存储,4...
  • 首先,得看看Object类的...声明一下,Company这个并没有重写equals方法,所以Object类它本身比较的是对象的实际地址 接下来再来看看Stringequals方法的源码 人家String这里才是真正的比较的内容,所...
  • Object类中有toString方法,equals方法 toString()重写: equals()方法: 双等于比较的是,是否为同一个对象 equals比较的是,两个对象像不像package test;public class Teacher { private String name; ...
  • String中的equals方法是比较两个对象中的内容是否相同。 底层源码: public boolean equals(Object anObject) { if (this == anObject) { return true; } if (anObject instanceof String) { ...
  • 今天在无意中发现一个小知识点,难度不大就是简单和大家分享一下。String str1 = new String("abc");...System.out.println(str1.equals(str2));//true System.out.println(str1.hashCode());//96354 System.out.prin
  • Object类是所有的父类 若一个未使extends明确标识继承关系,会默认继承Object类(包括数组) Java中每个都可以用Object类定义的方法 2、Object类中的equals方法和toString方法 说明:Object类中定...
  • 1.首先我们看看Object类中的equals方法 public boolean equals(Object obj) { return (this == obj); } 我们可以看出Object类中判断的是否是同一个对象,我们接下来来看看下面这个例子 Employee emp1 = new ...
  • Java基础:Object类equals和hashCode方法

    千次阅读 2017-10-26 17:56:17
    hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值,也就是哈希码,哈希码并不是完全唯一的,它是一种算法,让同一个的对象按照自己不同的特征尽量的有不同的哈希码,但不表示不同的对象哈希码...
  • Object类和String类equals方法的区别

    千次阅读 2016-05-15 15:20:45
    Stringequals方法和“==” 相信很多学习过Java的同学都知道,在比较两个String对象的内容是否相同时是使用equals方法的 如:String str1=new String(“A”);  String str2=new String(“B”);  String str...
  • Object类equals方法

    千次阅读 2016-07-05 21:56:21
    class Cat {  int color;  int height;  int weight;  public boolean equals(Object obj)  {  if(obj == null)  return false;  else  {  
  • Object类 toString方法 equals方法
  • object类中的equals与自定义equal方法详解 this怎么了解?this == obj表示什么? /*Object 中的 equals() 方法*/ Object 中的 equals() 方法 public boolean equals(Object obj) { return (this == obj);...
  • 如何重写ObjectEquals方法

    千次阅读 2006-10-25 11:29:00
    为基类没有重写Object.Equals方法的引用类型实现Equals2。为基类重写Object.Equals方法的引用类型实现Equals3。为值类型实现Equals具体实现代码如下:(其中为了节省篇幅,没有重写GetHashCode方法)using System;//...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 522,276
精华内容 208,910
关键字:

object类的equals方法