精华内容
下载资源
问答
  • java比较两个对象是否相等

    千次阅读 2018-06-21 00:25:22
    java比较两个对象,可以通过重写equals()实现。1.比较对象时, ==比较的是地址,而equals()比较的是对象内容2.重写equals()方法必须重写hashCode()示例代码如下:Person.java可以自动生成get()、set()、构造函数、...

    java比较两个对象,可以通过重写equals()实现。

    1.比较对象时, ==比较的是地址,而equals()比较的是对象内容

    2.重写equals()方法必须重写hashCode()

    示例代码如下:

    Person.java

    可以自动生成get()、set()、构造函数、equals()、hashCode等方法。

    Idea选择类的代码,写入属性名,如下为name和age,然后右键-->Generate,就可以自动生成了。

    eclipse类似。搜索下快捷键也可以自动生成。

    ----------------------------------------------------------

    public class Person {
        private String name;
        private int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }

        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;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;

            Person person = (Person) o;

            if (age != person.age) return false;
            return name.equals(person.name);
        }

        @Override
        public int hashCode() {
            int result = name.hashCode();
            result = 31 * result + age;
            return result;
        }

    }

    ---------------------------------------------------------

    public class ObjectEquals {
        public static void main(String[] args) {
            Person person1=new Person("lin",25);
            Person person2=new Person("lin",25);
            System.out.println("通过==比较对象:");
            if(person1==person2) {
                System.out.println("person1和person2是同一个人");
            }else {
                System.out.println("person1和person2不是同一个人");
            }
            System.out.println("通过重写equals()和hashCode()比较对象:");
            if(person1.equals(person2)) {
                System.out.println("person1和person2是同一个人");
            }else {
                System.out.println("person1和person2不是同一个人");
            }
        }


    ----------------------------------------------------------------------

    结果如下所示:

    hashCode根据这个方法的声明可知,该方法返回一个int类型的数值,并且是本地方法,因此在Object类中并没有给出具体的实现。  为何Object类需要这样一个方法?它有什么作用呢?



    展开全文
  • 下面小编就为大家带来一篇基于java中两个对象属性的比较。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了Java比较两个List的值是否相等的方法,涉及java针对队列比较的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • Java中如何判断两个对象是否相等

    千次阅读 2019-08-17 17:53:45
    如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。 从以下几个点来理解equals和hashCode方法: 1、equals的作用及与==的区别。 2、hashcode的作用及与equals的关系。 1、...

    如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。
    从以下几个点来理解equals和hashCode方法:

    1、equals的作用及与==的区别。
    2、hashcode的作用及与equals的关系。

    1、equals的作用及与== 的区别。
    equals被用来判断两个对象是否相等。
    equals通常用来比较两个对象的内容是否相等,用来比较两个对象的地址是否相等。
    equals方法默认等同于“

    Object类中的equals方法定义为判断两个对象的地址是否相等(可以理解成是否是同一个对象),地址相等则认为是对象相等。这也就意味着,我们新建的所有类如果没有复写equals方法,那么判断两个对象是否相等时就等同于“==”,也就是两个对象的地址是否相等。
    Object类中equals的方法实现如下:

    public boolean equals(Object obj) {
    return (this == obj);
    }
    但在我们的实际开发中,通常会认为两个对象的内容相等时,则两个对象相等,equals返回true。对象内容不同,则返回false。
    所以可以总结为两种情况
    1、类未复写equals方法,则使用equals方法比较两个对象时,相当于==比较,即两个对象的地址是否相等。地址相等,返回true,地址不相等,返回false。
    2、类复写equals方法,比较两个对象时,则走复写之后的判断方式。通常,我们会将equals复写成:当两个对象内容相同时,则equals返回true,内容不同时,返回false。
    举个例子:

    public class EqualTest {
        public static void main(String[] args) {
            Person p1 = new Person(10,"张三");
            Person p2 = new Person(10,"张三");
            System.out.println(p1.equals(p2));
        }
    }
    class Person{
        int age;
        String name;
        public Person(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }
    

    Person未复写equals方法,则默认使用了Object中的equals,即为两个对象(p1和p2)的内存地址判断,p1和p2很明显内存地址不同,所以输出结果很明显为false。
    如果我们复写equals方法呢?我们认为名字和年龄一样的就是同一个人,那么p1和p2都表示10岁的张三,这两个对象应该是相等的。复写的equals方法如下:

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    

    同样的,执行上述用例,得到的结果是true。
    BTW:如果equals方法返回true,那么是否也是true?
    不一定是true。equals返回true有两种可能,一种是两个对象地址相同,一种是两个对象内容相同。当内容相同时,地址可能不同,所以
    比较的结果可能为false。
    我们把main方法加上对==的判断,如下:

    public static void main(String[] args) {
    	Person p1 = new Person(10,"张三");
    	Person p2 = new Person(10,"张三");
    	System.out.println(p1.equals(p2));
    	System.out.println(p1 == p2);
    }
    

    输出结果很明显 p1==p2的结果是false。

    补充Java中对Equals的要求:

    1. 对称性:如果x.equals(y)返回是"true",那么y.equals(x)也应该返回是"true"。
    2. 反射性:x.equals(x)必须返回是"true"。
    3. 类推性:如果x.equals(y)返回是"true",而且y.equals(z)返回是"true",那么z.equals(x)也应该返回是"true"。
    4. 一致性:如果x.equals(y)返回是"true",只要x和y内容一直不变,不管你重复x.equals(y)多少次,返回都是"true"。
    5. 非空性,x.equals(null),永远返回是"false";x.equals(和x不同类型的对象)永远返回是"false"。

    2、hashCode的作用及与equals的关系。
    hashCode的作用是用来获取哈希码,也可以称作散列码。实际返回值为一个int型数据。用于确定对象在哈希表中的位置。
    Object中有hashcode方法,也就意味着所有的类都有hashCode方法。
    但是,hashcode只有在创建某个类的散列表的时候才有用,需要根据hashcode值确认对象在散列表中的位置,但在其他情况下没用。
    java中本质上是散列表的类常见的有HashMap,HashSet,HashTable
    所以,如果一个对象一定不会在散列表中使用,那么是没有必要复写hashCode方法的。但一般情况下我们还是会复写hashCode方法,因为谁能保证这个对象不会出现再hashMap等中呢?
    举个例子:
    两个对象equals相等的时候,hashcode并不一定相等。

    public class EqualTest {
        public static void main(String[] args) {
            Person p1 = new Person(10, "张三");
            Person p2 = new Person(10, "张三");
            System.out.println(
                    "p1.equals(p2)=" + p1.equals(p2) + ", p1.hashcode=" + p1.hashCode() + ", p2.hashcode=" +p2.hashCode());
        }
    }
    class Person {
        int age;
        String name;
        public Person(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
    }
    

    Person没有复写hashCode方法,使用Object默认的hashCode实现,输出结果如下:

    p1.equals(p2)=true, p1.hashcode=246688959, p2.hashcode=1457895203
    

    从结果可以看出,equals虽然相同,但是p1和p2的hashcode并不相同。

    如果Person用于散列表的类中呢,这里用HashSet来做测试。

    public class EqualTest {
        public static void main(String[] args) {
            Person p1 = new Person(10, "张三");
            Person p2 = new Person(10, "张三");
            System.out.println(
                    "p1.equals(p2)=" + p1.equals(p2) + ", p1.hashcode=" + p1.hashCode() + ", p2.hashcode=" +p2.hashCode());
            HashSet<Person> set = new HashSet<Person>();
            set.add(p1);
            set.add(p2);
            System.out.println(set);
        }
    }
    class Person {
        int age;
        String name;
        public Person(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
        @Override
        public String toString() {
            return "Person [age=" + age + ", name=" + name + "]";
        }
    }
    

    输出结果

    p1.equals(p2)=true, p1.hashcode=246688959, p2.hashcode=1457895203
    [Person [age=10, name=张三], Person [age=10, name=张三]]
    

    p1和p2的equals相同,我们认为是两个对象相等,但是这两个对象竟然同时出现再hashSet中,hashSet中是不会出现两个相同的元素的。
    那问题在哪里?
    hashset在添加一个元素的时候,会做如下判断:
    1、如果添加元素的hashcode相等并且 对象equals为true或对象== 时,则认为是同一个元素,不添加到新元素中。
    2、如果不符合上述条件,则认为是一个新元素,添加到set中。
    所以,虽然p1和p2equals比较时相等,但是hashcode并不一样,所以在往set中添加的时候认为是两个不同的元素,所以才会出现了p1和p2同时在set中的情况。

    我们改进下,复写一下hashcode方法,如下:

    class Person {
        int age;
        String name;
        public Person(int age, String name) {
            super();
            this.age = age;
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            result = prime * result + ((name == null) ? 0 : name.hashCode());
            return result;
        }
        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Person other = (Person) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
        @Override
        public String toString() {
            return "Person [age=" + age + ", name=" + name + "]";
        }
    }
    

    重新执行结果:

    p1.equals(p2)=true, p1.hashcode=776160, p2.hashcode=776160
    [Person [age=10, name=张三]]
    

    于是看到set中仅有一个Person值了。

    补充几点:
    1、新建一个类,尤其是业务相关的对象类的时候,最好复写equals方法。
    2、复写equals方法时,同时记着要复写hashCode方法,谁能保证说这个对象一定不会出现在hashMap中呢?如果你用的是eclipse的自动代码生成,你会发现eclipse中复写equals和hashCode是在一起的。

    引申出几个经常在面试中问到的问题:
    1、两个对象,如果a.equals(b)==true,那么a和b是否相等?
    相等,但地址不一定相等。
    2、两个对象,如果hashcode一样,那么两个对象是否相等?
    不一定相等,判断两个对象是否相等,需要判断equals是否为true。

    注意:
    是否可以直接根据hashcode值判断两个对象是否相等吗?肯定是不可以的,因为不同的对象可能会生成相同的hashcode值。虽然不能根据hashcode值判断两个对象是否相等,但是可以直接根据hashcode值判断两个对象不等,如果两个对象的hashcode值不等,则必定是两个不同的对象。如果要判断两个对象是否真正相等,必须通过equals方法。

    也就是说对于两个对象,如果调用equals方法得到的结果为true,则两个对象的hashcode值必定相等;

    如果equals方法得到的结果为false,则两个对象的hashcode值不一定不同;

    如果两个对象的hashcode值不等,则equals方法得到的结果必定为false;

    如果两个对象的hashcode值相等,则equals方法得到的结果未知。

    展开全文
  • 在本篇文章里小编给大家分享的是关于java比较两个list是否相同equals的代码详解,有需要的朋友们可以参考学习下。
  • Java 中判断两个对象是否相等

    千次阅读 2020-04-28 18:21:08
    嗯先铺垫一下Java中的相等问题,比较方法有equals和==,比较的方向有内容相等和对象相等。 1.equals:只能比较对象,比较对象地址是否相等;可以重写equals方法,比如String重写equals方法改为内容是否相等。 2.==:...

    嗯先铺垫一下Java中的相等问题,比较方法有equals和==,比较的方向有内容相等和地址相等。
    1.equals:只能比较对象,比较对象地址是否相等;可以重写equals方法,比如String重写equals方法改为内容是否相等。 
    2.==:可以比较基础数据类型和对象,基础数据类型比较值是否相等,对象比较地址是否相等。

    看一个经典的问题,String的equals问题。

    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException, InstantiationException {
           String  ss= "test";
           String  ss1= "test";
           String  ss2= new String("test");
           System.out.println(ss==ss1);
           System.out.println(ss.equals(ss1));
           System.out.println(ss==ss2);
           System.out.println(ss.equals(ss2));
    	}

    输出结果:
    ss==ss1:true
    ss.equals(ss1):true
    ss==ss2:false
    ss.equals(ss2):true

            其实这个问题上“==”的使用一直是没有异议的,就是看String的地址是否相等。主要问题是equals的方法,很多博客在说的时候没有区分String和Object在使用equals方法的区别,这很容易产生误导(至少我很长一段时间就分不清equals的使用情况)。我们看一下String.equals()和Object.equals()的源码就很容易理解这个问题。

    //String的equals方法

    public boolean equals(Object anObject) {
    	//首先是object同样的比较方法,因为地址相等那么值肯定是相等的,也就没有必要进行下面的比较了
    	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;
    }

    //object 的equals方法

     public boolean equals(Object obj) {
    	return (this == obj);
    }

       总结:我们看两个对象是否是同一个对象就是看内存地址是否相等。(重点说明一下这里说的不是对象是否相等)
    这个不难理解,java中对象是存在java堆中,每new一个,就相当于新创建一个对象,系统就会分配一个存储对象的唯一地址,如果两个对象的地址是相同的那么这两个对象自然也就是同一个对象。

     

    展开全文
  • java比较两个对象是否相等直接使用equals方法进行判断肯定是不会相同的。 例如: Person person1 =new Person("张三"); Person person2 =new Person("张三"); boolean falg = person1.equals(person1); falg 的...

    java比较两个对象是否相等直接使用equals方法进行判断肯定是不会相同的。

    例如:

    Person  person1  =new Person("张三");

    Person  person2  =new Person("张三");

    boolean  falg = person1.equals(person1);

    falg 的值是false;

    如果要判断两个对象相同就需要重写父类的equals方法和hashCode方法;

    这时再次测试时falg的值就是true。

     

    转载于:https://www.cnblogs.com/zzjbk/p/4948477.html

    展开全文
  • Java-对象相等判断

    千次阅读 2019-02-18 16:40:47
    Java-对象相等判断引用相等性和对象相等性引用相等性对象相等性equals和hashCodeequalsJDK中说明了实现equals()方法应该遵守的约定:hashCodehash码相同的情况hash码不相同的情况JDK中对hashCode()方法的作用,以及...
  • Java比较两个对象中全部属性值是否相等

    万次阅读 多人点赞 2018-12-14 16:01:49
    Java比较两个对象中全部属性值是否相等 例如下述Java类: import java.io.Serializable; import java.util.List; public class Bean_Topology implements Serializable { private static final long ...
  • Java比较两个对象的属性值是否相等 import java.beans.Introspector; import java.beans.PropertyDescriptor; import java.lang.reflect.Method; import java.sql.Timestamp; import java.util.*; /** * 比较两个...
  • 主要思想还是通过反射获取类的属性的getter方法,调用getter方法获取值并比较是否相同相同就忽略不同就返回属性信息,方法都不复杂,主要是利用反射思想。 代码如下: 定义一个类保存比较后的返回值信息 @Data ...
  • 通常我们会比较基本类型、引用类型、数组等是否相等,很少会 比较对象的Class实例对象是否相等,那么class实例对象如何比较相等呢? 可以使用“==”比较是否相等 obj.getClass() == ClassEqualTest.class 可以...
  • 相等的方法是:先比较对象的hashCode()值是否相等,如果不相等就认为两个对象不相等,如果两个对象的hashCode相等就继续调用equals() 方法进一步判断两个对象是否相等,如果equals()方法返回true认为两个对象相等,...
  • java对象相等问题

    万次阅读 多人点赞 2019-07-31 19:17:15
    小学生表示已经崩溃,是不是java已经无爱了。但是我可不会就这样放弃,到底是什么原因呢? 查看Integer的valueOf方法的源码如下: public static Integer valueOf(int i) { final int offset = 128; if (i >= -...
  • apache commons提供的只有collections的对比,因此,本文利用jackson将对象序列化为map,通过对两个map的比较确定对象是否相等访问我的个人网站获取更多文章在撰写本文的时候,发现之前的方法麻烦了,研究了java map...
  • 主要介绍了利用Java反射机制实现对象相同字段的复制操作,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • public class OperatorsAndExpressions_6 { void equalsMethod2() { String s1=new String("hello");... //用于对象比较相等的运算符 OperAndExp.equalsMethod2(); } } false true false
  • Java中如何判断两个对象是否相等Java equals and ==)

    万次阅读 多人点赞 2017-12-15 02:16:13
    如何判断两个对象相等,这个问题实际上可以看做是如何对equals方法和hashcode方法的理解。 从以下几个点来理解equals和hashCode方法: 1、equals的作用及与==的区别。 2、hashcode的作用及与equals的关系。 ...
  • java对象相等

    2018-05-07 17:05:06
    我之前写过关于这里的文章,这里我重新写一篇文章Java中Object类中的hashCode()和equals()方法如下所示: public boolean equals(Object obj) { return (this == obj); } public int hashCode() { int lockWord = ...
  • 标题:java集合判断对象相等比较大小的方法 判断Java集合对象相同: (1)判断equals是否返回true; (2)判断hascode是否相等; package edu.xalead; import java.util.HashSet; public class Test { /** ...
  • ==操作符用于比较两个对象的地址是否相等 equals()用于比较两个对象的内容是否相等 // String对象比较 String alita=new String("小萝莉"); String luolita=new String("小萝莉"); System.out.println(alita.equals...
  • == 始终比较的是两个对象的身份, 比较的是两个引用中保存的地址的值 对于新创建的类,如果没有重写equals方法,默认equals也是比较身份 我们可以通过重写equals方法的方式来自定义"什么叫相等" 我们可以仍然按照...
  • 判断一个类的两个对象是否相等有两层含义:1、判断它们是否引用同一个实例。2、当两个对象分别引用不同的实例时,判断它们...java约定一个类的equals()方法用于比较该类的两个对象是否相等,这里的相等包括引用同一...
  • 主要介绍了JS 比较两个Json对象的值是否相等的实例,有需要的朋友可以参考一下
  • java判断2个对象是否相等 java 判断2个对象是否相等只能重写equals方法和hashCode方法 package com.example.demo; import java.util.Objects; public class Student { private Long id; private String name; ...
  • 在List.contains()方法比较list对象是否已包含某个对象实例,需要重写这个对象的equals对象,用对象中某个(或几个)属性作为判断对象是否一致的条件(contains方法依据Object的equals方法来判断是否包含某一属性...
  • import java.beans.PropertyDescriptor; import java.lang.reflect.Field; import java.lang.reflect.Method; public class CompareObejct { private CompareStatus status; /** * 之前原始的值 */ ...
  • public class HelloWorl { public static void main(String[] args) { Data a = new Data(2017,7,28); Data c = new Data(2017,7,28); if(a.equals(c)) System.out.println("true");...
  • 目录 引言 问题 实现 引言 通常情况下,比较自定义类的两个对象的内容是否相等就是比较它们的属性值是否相等。由于Object类中的equals方法比较的是两个引用的地址值是否相同,所以如果要比较自定义类的内容,我们要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,044,354
精华内容 417,741
关键字:

java比较对象是否相等

java 订阅