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

推荐阅读更多精彩内容