equals 与 hashCode 笔记一

本系列文章准备从以下三方面入手，分别是 equals，hashCode 和常见的面试题。

第一篇文章主要讲解 equals 方法，分为以下部分：

1. 关于 equals
2. 重写 equals() 原因
3. equals() 原则
4. getClass 与 instanceof 的区别
5. 如何更好地重写 equals()

关于 equals

" == "操作符主要比较的是操作符两端对象的内存地址。如果两个对象的内存地址是一致的，那么就返回 true ；反之，则返回 false 。

Java的数据类型分为：

• 基本数据类型：8种，分别为byte,short,int,long,float,double,char,boolean
  除了 float 和 double 外，其他使用 == 进行数值比较。

• 复合数据类型：类实例化对象， 当他们用 == 进行比较的时候，比较的是他们在内存中的存放地址，所以，除非是同一个 new 出来的对象，他们的比较后的结果为 true，否则比较后结果为 false 。

重写 equals() 原因

JAVA 当中所有的类都是继承于 Object 这个基类的，在 Object 中的基类中定义了一个 equals 的方法，这个方法的初始行为是比较对象的内存地址。

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

虽然有时候 Object 的 equals() 方法可以满足我们一些基本的要求，但是我们必须要清楚我们很大部分时间都是进行两个对象的比较，这个时候 Object 的 equals() 方法就不可以了，像 String，Integer，Date 等封装类都对 equals() 方法进行了重写。比如 String 类：

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

equals() 原则

在 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。

getClass 与 instanceof 的区别

我们在覆写 equals() 方法时，一般都是推荐使用 getClass 来进行类型判断，不是使用 instanceof。我们都清楚 instanceof 的作用是判断其左边对象是否为其右边类的实例，返回 boolean 类型的数据。也可以用来判断继承中的子类的实例是否为父类的实现。

父类Person的实现：

public class Person {
    protected String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Person(String name){
        this.name = name;
    }
    
    @Override
    public boolean equals(Object object){
        // 1->先比较引用是否相同
        if(this == object) {    
            return true;
        }
        // 2->再比较类型是否一致
        if(object instanceof Person){
        // if(object.getClass() == Person.class){
            Person p = (Person) object;
        // 3->最后比较内容是否相同
            if(p.getName() == null || name == null){
                return false;
            }
            else{
                return name.equalsIgnoreCase(p.getName ());
            }
        }
        return false;
   }
}

子类Employee实现：

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

    @Override
    public boolean equals(Object object){
        if(object instanceof Employee){
        // if(object.getClass() == Employee.class){
            Employee e = (Employee) object;
            return super.equals(object) && e.getId() == id;
        }
        return false;
    }
}

测试类 EqualsTest 的实现：

public class EqualsTest {

    public static void main(String[] args) {
        
        Employee e1 = new Employee("Mary", 18);
        Employee e2 = new Employee("Mary", 19);
        Person p1 = new Person("Mary");

        System.out.println(p1.equals(e1));
        System.out.println(p1.equals(e2));
        System.out.println(e1.equals(e2));
    }

}

测试结果：

true
true
false

分析：因为 e1、e2 明明是两个不同的类，但为什么会出现这个情况？首先 p1.equals(e1)，是调用 p1 的 equals 方法，该方法使用 instanceof 关键字来检查 e1 是否为 Person 类，这里我们再看看 instanceof：判断其左边对象是否为其右边类的实例，也可以用来判断继承中的子类的实例是否为父类的实现。他们两者存在继承关系，肯定会返回 true 了，而两者 name 又相同，所以结果肯定是 true。所以重写 equals 时推荐使用 getClass 进行类型判断。而不是使用 instanceof。

那 String 类重写 equals 时，为什么使用了 instanceof 关键字呢？原因在于： String 类采用了 final ，即不允许被继承，所以不会出现上述问题。

如何更好地重写 equals()

关于重写 equals() 的模板：

1. 先比较引用是否相同
2. 再比较类型是否一致
3. 最后比较内容是否相同

具体的例子如上述类Person的实现。

参考连接

1. equals() 方法总结
2. 聊聊Java中的 " == "、equals以及hashCode