Java重写equals方法

╰半夏微凉° 2022-12-02 10:50 123阅读 0赞

### 文章目录 ###

*   *  一、为什么equals()方法要重写？
     *  二、怎样重写equals()方法？
     *   *  1、自反性原则
         *  2、对称性原则
         *  3、传递性原则
         *  4、必须覆写hashCode方法这样结果就是三个false。

## 一、为什么equals()方法要重写？ ##

判断两个对象在逻辑上是否相等，如根据类的成员变量来判断两个类的实例是否相等，而`继承Object中的equals方法只能判断两个引用变量是否是同一个对象`。这样我们往往需要重写equals()方法。  
我们向一个没有重复对象的集合中添加元素时，集合中存放的往往是对象，我们需要先判断集合中是否存在已知对象，这样就必须重写equals方法。

## 二、怎样重写equals()方法？ ##

重写equals方法的要求：  
1、自反性：对于任何非空引用x，x.equals(x)应该返回true。  
2、对称性：对于任何引用x和y，如果x.equals(y)返回true，那么y.equals(x)也应该返回true。  
3、传递性：对于任何引用x、y和z，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)也应该返回true。  
4、一致性：如果x和y引用的对象没有发生变化，那么反复调用x.equals(y)应该返回同样的结果。  
5、非空性：对于任意非空引用x，x.equals(null)应该返回false。

### 1、自反性原则 ###

在JavaBean中，经常会覆写equals方法，从而根据实际业务情况来判断两个对象是否相等，比如我们写一个person类，根据姓名来判断两个person类实例对象是否相等。代码如下：

public class Person {
        private String name;
    
        public Person(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public boolean equals(Object obj) {
            if (obj instanceof Person) {
                Person person = (Person) obj;
                return name.equalsIgnoreCase(person.getName().trim());
            }
            return false;
        }
    
        public static void main(String[] args) {
            Person p1 = new Person("张三");
            Person p2 = new Person("张三    ");
            List<Person> list = new ArrayList<Person>();
            list.add(p1);
            list.add(p2);
            System.out.println("是否包含张三：" + list.contains(p1));
            System.out.println("是否包含张三：" + list.contains(p2));
        }
    }

list中含有这个生成的person对象，结果应该为true，但是实际结果：这里考虑了字符串空格的问题，去除前后的空格。  
是否包含张三：true  
是否包含张三：false  
第二个为什么会是false呢？  
原因在于list中检查是否含有元素时是通过调用对象的equals方法来判断的，也就是说 contains（p2）传递进去会依次执行p2.equals(p1)、p2.equals(p2)，只要一个返回true，结果就是true。但是这里p2.equals(p2)返回的是false？由于我们对字符前后进行了空格的切割造成p2.equals(p2)的比较实际上是：“张三 ”.equals（“张三”），一个有空格，一个没有空格就出错了。  
这个违背了equals的自反性原则：对于任何非空引用x，x.equals(x)应该返回true。  
这里只要去掉trim方法就可以解决。

### 2、对称性原则 ###

上面这个例子，还并不是很好，如果我们传入null值，会怎么样呢？增加一条语句：Person p2=new Person(null);  
结果：

> 是否包含张三：true  
> Exception in thread “main” java.lang.NullPointerException//空指针异常

原因在执行p2.equals(p1)时，由于p2的name是一个null值，所以调用name.equalsIgnoreCase()方法时就会报空指针异常。  
这是在覆写equals方法时没有遵循对称性原则：对于任何应用x,y的情形，如果想x.equals(y)返回true，那么y.equals(x),也应该返回true。  
应该在equals方法里加上是否为null值的判断：

@Override
        public boolean equals(Object obj) {
            if (obj instanceof Person) {
                Person person= (Person) obj;
                if (person.getName() == null || name == null) {
                    return false;
                }else{
                    return name.equalsIgnoreCase(person.getName());
                }
            }
            return false;
        }

### 3、传递性原则 ###

现在我们有一个Employee类继承自person类：

public class Employee extends Person{
        private int id;
    
    
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public Employee(String name,int id) {
            super(name);
            this.id = id;
            // TODO Auto-generated constructor stub
        }
        @Override
        public boolean equals(Object obj) {
            if(obj instanceof Employee){
                Employee e = (Employee)obj;
                return super.equals(obj) && e.getId() == id;
            }
            return super.equals(obj);
        }
    
        public static void main(String[] args){
            Employee e1=new Employee("张三",12);
            Employee e2=new Employee("张三",123);
            Person p1 = new Person("张三");
    
            System.out.println(p1.equals(e1));
            System.out.println(p1.equals(e2));
            System.out.println(e1.equals(e2));
        }
    }

只有在name和ID都相同的情况下才是同一个员工，避免同名同姓的。在main里定义了，两个员工和一个社会闲杂人员，虽然同名同姓但肯定不是同一个人。运行结果应该三个都是false才对。但是：  
true  
true  
false  
p1尽然等于e1,也等于e2，不是同一个类的实例也相等了？  
因为p1.equals(e1)是调用父类的equals方法进行判断的它使用instanceof关键字检查e1是否是person的实例，由于employee和person是继承关系，结果就是true了。但是放过来就不成立，e1,e2就不等于p1，这也是违反对称性原则的一个典型案例。  
e1竟然不等于e2？  
e1.equals(e2)调用的是Employee的equals方法，不仅要判断姓名相同还有判断工号相同，两者的工号不同，不相等时对的。但是p1等于e1,也等于e2，e1却不等于e2，这里就存在矛盾，等式不传递是因为违反了equals的传递性原则：对于实例对象x、y、z；如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)也应该返回true。  
上述情况会发生是因为父类使用instanceof关键字(是否是这个特定类或者是它的子类的一个实例)，用来判断是否是一个类的实例对象的，这很容易让子类“钻空子”。  
想要解决也很简单，使用getClass进行类型的判断，person类的equals方法修改如下：

@Override
        public boolean equals(Object obj) {
            if (obj != null && obj.getClass() == this.getClass()) {
                Person person= (Person) obj;
                if (person.getName() == null || name == null) {
                    return false;
                }else{
                    return name.equalsIgnoreCase(person.getName());
                }
            }
            return false;
    }

### 4、必须覆写hashCode方法这样结果就是三个false。 ###

覆写equals方法就必须覆写hashCode方法，这是Javaer都知道的。  
原因就是HashMap的底层处理机制是以数组的方式保存map条目的，这其中的关键是这个数组下标的处理机制：  
依据传入元素的hashCode方法的返回值决定其数组的下标，如果该数组位置上已经有了map条目，且与传入的键值相等则不处理，若不相等则覆盖；如果数组位置没有条目，则插入，并加入到map条目的链表中。同理检查键是否存在也是根据哈希吗确定文职，然后遍历查找键值的。  
那么对象的hashCode方法返回的是什么呢？  
他是一个对象的哈希码，是有Object类的本地方法生成的，确保每个对象有一个哈希码。  
1、重写equals方法实例 部分代码参考[http://blog.csdn.net/wangloveall/article/details/7899948][http_blog.csdn.net_wangloveall_article_details_7899948]  
重写equals方法的目的是判断两个对象的内容(内容可以有很多，比如同时比较姓名和年龄，同时相同的才是用一个对象)是否相同。  
如果不重写equals，那么比较的将是对象的引用是否指向同一块内存地址，重写之后目的是为了比较两个对象的value值是否相等。特别指出利用equals比较八大包装对象，（如int，float等）和String类（因为该类已重写了equals和hashcode方法）对象时，默认比较的是值，在比较其它自定义对象时都是比较的引用地址。

package com.lk.C;
    
    class User {
        private String name;
        private int age;
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public void setName(String name) {  
            this.name = name;  
        }
        public String getName() {  
            return name;  
        }
        public boolean equals(Object obj) {  
            if(this == obj) {  
                return true;  
            }  
            if(null == obj) {  
                return false;  
            }  
            if(this.getClass() != obj.getClass()) {  
                return false;  
            }  
    
            User user = (User) obj;  
            if(this.name.equals(user.name)&&this.age == user.age) {  
                return true;  
            }  
            return false;  
        }  
        
    }  
    
    public class Test6 {  
        public static void main(String[] args) {  
            User userA = new User();  
            userA.setName("王明");
            userA.setAge(10);
    
            User userB = new User();  
            userB.setName("王明");
            userB.setAge(10);
    
            User userC = new User();  
            userC.setName("王亮");
            userC.setAge(10);
    
            System.out.println("userA equals userB:" + userA.equals(userB));  
            System.out.println("userA equals userC:" + userA.equals(userC));
        }  
    }

> userA equals userB:true  
> userA equals userC:false

在Java中，问什么说重写了equals方法都要进而重写Hashcode方法呢？  
原因如下：当equals此方法被重写时，通常有必要重写 hashCode 方法，以维护 hashCode 方法的常规协定，该协定声明相等对象必须具有相等的哈希码。如下：  
(1) 当obj1.equals(obj2)为true时，obj1.hashCode() == obj2.hashCode()必须为true  
(2) 当obj1.hashCode() == obj2.hashCode()为false时，obj1.equals(obj2)必须为false  
hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。  
这样如果我们对一个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但不重写hashcode，那么我们再new一个新的对象，当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致。  
2、看看下面的三段程序

package com.lk.C;
    
    public class Test7 {
        public static void main(String[] args) {
            int a = 10;
            int b = 10;
            System.out.print("基本类型a==b:");
            System.out.println(a == b);
            System.out.println("-----");
            
            String s1 = "abc";
            String s2 = "abc";
            System.out.print("String类型是s1==s2:");
            System.out.println(s1 == s2);
            System.out.println("-----");
            
            String s3 = new String("abc");
            String s4 = new String("abc");//可以看出==比较的是栈的地址是否相同
            System.out.print("String类型用new String()是s1==s2:");
            System.out.println(s3 == s4);
            System.out.println(s1 == s3);
            System.out.println("-----");
            
            Integer i1 = 1;
            Integer i2 = 1;
            System.out.print("包装类型是i1==i2:");
            System.out.println(i1 == i2);
            System.out.println("-----");
            
            Integer i3 = 128;
            Integer i4 = 128;//此时输出false是因为Integer在-128-127之间会缓存，超出这个范围就不会缓存了
            System.out.print("包装类型是i3==i4:");
            System.out.println(i3 == i4);
            System.out.println("-----");
            
            Integer i5 = new Integer("1");
            Integer i6 = new Integer("1");
            System.out.print("包装类型用new Integer()是i5==i6:");
            System.out.println(i5 == i6);//用new Integer()多少都不会缓存
            System.out.println("-----");
            
            A a1 = new A(1);
            A a2 = new A(1);
            A a3 = a2;
            System.out.print("普通引用类型a1 == a2：");
            System.out.println(a1 == a2);
            System.out.println(a2 == a3);//对象赋给新对象连地址都是相同的
            System.out.println("-----");
        }
    }
    
    class A{
        int i;
        public A(int i){
            this.i = i;
        }
    }

基本类型a==b:true
    -----
    String类型是s1==s2:true
    -----
    String类型用new String()是s1==s2:false
    false
    -----
    包装类型是i1==i2:true
    -----
    包装类型是i3==i4:false
    -----
    包装类型用new Integer()是i5==i6:false
    -----
    普通引用类型a1 == a2：false
    true
    -----

package com.lk.C;
    
    public class Test8 {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            System.out.println("基本类型没有equals方法");
            System.out.println("-----");
            
            String s1 = "abc";
            String s2 = "abc";
            System.out.print("String类型的equals方法:");
            System.out.println(s1.equals(s2));
            System.out.println("-----");
            
            String s3 = new String("abc");
            String s4 = new String("abc");//可以看出比较equals方法比较的是堆里的值是否相同
            System.out.print("String类型的new String()的equals方法：");
            System.out.println(s3.equals(s4));
            System.out.println("-----");
            
            System.out.print("String用==赋值和用new String()赋值的比较：");
            System.out.println(s1.equals(s3));
            System.out.println("-----");
            
            Integer i1 = 1;
            Integer i2 = 1;
            System.out.print("包装类的equals方法：");
            System.out.println(i1.equals(i2));
            System.out.println("-----");
            
            Integer i3 = new Integer(1);
            Integer i4 = new Integer(1);
            System.out.print("包装类的new Integer()用equals方法：");
            System.out.println(i3.equals(i4));
            System.out.println("-----");
            
            System.out.print("Integer用==赋值和用new Integer()赋值的比较：");
            System.out.println(i1.equals(i3));
            System.out.println("-----");
        }
    
    }

基本类型没有equals方法
    -----
    String类型的equals方法:true
    -----
    String类型的new String()的equals方法：true
    -----
    String用==赋值和用new String()赋值的比较：true
    -----
    包装类的equals方法：true
    -----
    包装类的new Integer()用equals方法：true
    -----
    Integer用==赋值和用new Integer()赋值的比较：true
    -----

package com.lk.C;
    
    public class Test9 {
    
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            Student s1 = new Student("阿坤",21);
            Student s2 = new Student("阿坤",21);
            Student s3 = new Student();
            Student s4 = new Student();
            Student s5 = s1;
            System.out.print("普通类对象的==非默认构造：");
            System.out.println(s1 == s2);
            System.out.println(s1 == s5);
            System.out.println("-----");
            
            System.out.print("普通类对象的equals非默认构造：");
            System.out.println(s1.equals(s2));
            System.out.println(s1.equals(s5));
            System.out.println("-----");
            
            System.out.print("普通类对象的==默认构造：");
            System.out.println(s3 == s4);
            System.out.println("-----");
            
            System.out.print("普通类对象的equals默认构造：");
            System.out.println(s3.equals(s4));
            System.out.println("-----");
            
            System.out.print("对普通对象的属性进行比较equals：");
            System.out.println(s1.name.equals(s2.name));
            System.out.print("对普通对象的属性进行比较==：");
            System.out.println(s1.name == s2.name);
        }
    
    }
    class Student{
        public String name;
        public int age;
        public Student(){
            
        }
        public Student(String name,int age){
            this.name = name;
            this.age = age;
        }
        public void test(){
            System.out.println(this.name);
            System.out.println(this.age);
        }
    }

普通类对象的==非默认构造：false
    true
    -----
    普通类对象的equals非默认构造：false
    true
    -----
    普通类对象的==默认构造：false
    -----
    普通类对象的equals默认构造：false
    -----
    对普通对象的属性进行比较equals：true
    对普通对象的属性进行比较==：true

从以上的三个程序可以看出：  
1)对于 `==`：在简单类型中(int等)，这能使用该方法进行比较，这种类型没有equals方法，int的值是存在栈中的，`==`比较的是栈的内容是否相同。在String类型中，比较特殊，用String=“”；这种进行赋值时，两个相同的值用`==`比较也是相同的。但是用new String()，赋值就不相同。说明String=“”时，java会检查在堆中是否由相同的值，如果有，把新对象的地址也同老对象的地址赋为相同，因此`==`比较会相同。但是new String()开辟的就是两个栈，因此用`==`比较不会相同。对于包装类，如Integer=“”；时，在-128-127会有缓存，请看上面程序。其他的情况与String类似。  
2)对于equals：当时String类型或者是包装类，如Integer时，比较的就是堆中的值，Integer也无缓存之说。对于普通类，equals比较的内存的首地址，这时候和==是一样的，即比较两边指向的是不是同一个对象。详细请见程序三。

以下是一些在百度中找到的说法：[http://zhidao.baidu.com/link?url=AMYxGo3NunWY7irH5XLPlHUa0ywvyqgYEAdDUMKJlQvklm686MC\_D7ZjT3dX9BmuZWXXjWRV2QHelGJ8GzAxBK][http_zhidao.baidu.com_link_url_AMYxGo3NunWY7irH5XLPlHUa0ywvyqgYEAdDUMKJlQvklm686MC_D7ZjT3dX9BmuZWXXjWRV2QHelGJ8GzAxBK]

java中，
    (1)对于字符串变量来说,equal比较的两边对象的内容，所以内容相同返回的是true。
    至于你没问到的“==”，比较的是内存中的首地址，所以如果不是同一个对象，“==”不会返回true 而是false。
    举个简单的例子，
    String s1="abc", s2="abc";
    String s3 =new String("abc");
    String s4=new String("abc");
    s1==s2 //true，
    s1.equals(s2) //true,
    s3.equals(s3) //true，equal比较的是内容
    s3==s4//false，==比较的是首地址，所以是false
    (2)对于非字符串变量，equals比较的内存的首地址，这时候和==是一样的，即比较两边指向的是不是同一个对象，
    即
    Sample sa1 = new Sample();
    Sample sa2 = new Sample();
    sa1.equals(sa2) //false，因为不是同一对象 
    注意，如果加上
    sa1=sa2;
    那么
    sa1.equals(sa2) //true

[http_blog.csdn.net_wangloveall_article_details_7899948]: http://blog.csdn.net/wangloveall/article/details/7899948
[http_zhidao.baidu.com_link_url_AMYxGo3NunWY7irH5XLPlHUa0ywvyqgYEAdDUMKJlQvklm686MC_D7ZjT3dX9BmuZWXXjWRV2QHelGJ8GzAxBK]: http://zhidao.baidu.com/link?url=AMYxGo3NunWY7irH5XLPlHUa0ywvyqgYEAdDUMKJlQvklm686MC_D7ZjT3dX9BmuZWXXjWRV2QHelGJ8GzAxBK