转载

说说如何重写Java的equals方法

说Java的equals方法前需要先说说操作符 == ,因为很多新手都容易困惑,操作符 == 和equals方法的区别。

Java 操作符 ==

在Java的世界里,操作符 == 作用在基本数据类型( int short byte long float double boolean )上时比较的是逻辑相等,作用在对象上比较则是对象的内存地址。

其实操作符 == 对于基本数据类型比较的也是地址,只不过JVM帮我们做了一些操作,让它使用起来是逻辑相等。下面我们就来说说具体原因。

基本类型的定义都是发生在JVM的栈内存中的。比如我们定义一个变量 int i = 7 ,jvm将会在栈区划分一个区域存储 7,然后把地址赋给变量 i 。这样通过变量 i 就能找到 7。假设这个时候我们又定义了一个变量 int j = 7 jvm 在内存中发现已经有 7 这个值了;这个时候就直接把变量 j 指向7;也就是变量 i 和变量 j 内存地址是一致的。所以当我们操作 i == j 返回的是真。在假设这个时候我们又定义 i = 8 ,编译器将会重新划分一个区域存储 8,因为JVM发现内存中没有8这个值,然后将变量 i 的地址指向 8,而变量 j 的指向不会变。

Java equals() 方法

上面说了Java操作符 == 比较的是对象的内存地址。也就是验证对象的唯一性,只有个两个对象是同一个对象的时候,他们的内存地址才是相同的。但是我们日常开发中,大部分场景是想验证两个对象是否是逻辑相等。这个时候我们可以重写Object的equals()方法。

JAVA的世界里所有的类都继承自Object。所以每个类都包含eqauls()方法。Object中的equals()方法是这样定义的

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

从代码可以看出来还是比较的对象内存地址。如何重写eqauls()方法,就变得特别重要,因为一不小心就会造成很严重的错误。还是那句话除非特别必要而且很明确的需要逻辑相等,否则不要重写equals。

重写equals,应当遵守JavaSE的通用约定。

自反性(reflexive) :对于任何非 null 的引用值x, x.equals(x) 必须返回 true

对称性(symmetric): 对于任何非 null 的引用值 xy ,当且仅当 x.equals(y) 返回 true 时, y.equals(x) 必须返回 true

传递性(transitive): 对于任何非 null 的引用值 x , yz ,如果 x.equals(y) 返回 true ,并且 y.equals(z) 也返回 true ,那么 x.equals(z) 也必须返回 true

一致性(consistent): 对于任何非 null 的引用值x和y, 只要equals的比较操作在对象中所用的信息没有被修改,多次调用 x.equals(y) 就会一致的返回 true ,或者一致的返回 false

对于任何非 null 的引用值 xx.equals(null) 必须返回 false

如果你违反了上面的约定,你的程序也许就会变现的不正常。因为所有的集合类都依赖于传递给他的对象是否遵守equals约定。

根据以上原则我们尝试重写一个自定义的Java类的equals方法。假定我们定一个Book类,希望该类实现逻辑相等。然后重写equals方法。只要书名和出版社一致我们就认为是同一本书。

public class Book {
    private String name;
    private String publish;
    public Book(String name, String publish){
        this.name = name;
        this.publish = publish;
    }
    @Override
    public boolean equals(Object obj){

        //使用 == 检查参数是否为这个对象的引用。
        if(obj == this) return true;
        //使用instanceof 检查参数是否为正确类型。
        if (!(obj instanceof Book)) return false;

        //把参数转化成正确类型
        Book book = (Book) obj;

        //对于该类中的关键字段,检查参数中的字段是否与该对象中对应的字段匹配。
        return Objects.equals(name,book.name) &&
                Objects.equals(publish,book.publish);
    }

}

这样通过equals方法就可以比较两本书是否是同一本书了,注意我代码中注释部分内容,可以说是重写equals的一些通用技巧。

本来这篇文章写到这里应该结束了,但是说到重写equals就必须提重写hashCode

因为: 重写equals方法一定要重写hashCode方法。

如果不遵守上面这条规则,会给我们的程序带来意想不到的结果。

关于重写hashCode方法, JavaSE 一样给出了约定,如下:

  1. 在应用程序的执行期间,只要对象的equals方法的比较操作所用到的信息没有被修改,那么对这同一个对象调用多次hashCode方法,它必须始终如一地返回同一个整数。在同一个应用程序的多次执行过程中,这个整数可以不同。
  2. 如果两个对象根据equals(Object)方法是相等的,那么调用这两个对象中任一个对象的hashCode方法必须产生同样的整数结果。
  3. 如果两个对象根据equals(Object)方法是不相等的,那么调用这两个对象中任一个对象的hashCode方法,不要求必须产生不同的整数结果。然而,程序员应该意识到这样的事实,对于不相等的对象产生截然不同的整数结果,有可能提高散列表(hash table)的性能。

如果只重写了equals方法而没有重写hashCode方法的话,则会违反约定的第二条:相等的对象必须具有相等的散列码 hashCode

两个逻辑相等的对象,如果产生不同的hashCode 将会给HashMap等容器带来意想不到的结果。

举个例子:

public class BookStore {

    public static void main(String[] args){

        HashMap<Book,String> bookStore = new HashMap<Book,String>();
        Book book1 = new Book("java","frank publish");
        Book book2 = new Book("java","frank publish");
        bookStore.put(book1,"compute");
        String category = bookStore.get(book2);
        // print null;
        System.out.println(category);
    }
}

因为HashMap是根据对象的散列值确定在HashMap中的存储位置的。如果你不重写hashCode方法,那么book1和book2在JVM中是两个完全不同的对象,他们的hashCode也将会不同,所以在HashMap看来他们就不是同一本书。

所以重写完equals方法一定要重写hashCode方法,写完之后要核对是否符合上面提到的Object.hashCode通用约定。大家也可以参考《Effictive Java》这本书,书里面讲的很透彻。

最后还是那句话不要轻易的重写equals()方法。

原文  https://hellofrank.github.io/2019/09/21/说说如何重写Java的equals方法/
正文到此结束
Loading...