在Java中重写equals和hashCode时应该考虑哪些问题？

Question

重写 equals 和 hashCode 时必须考虑哪些问题/陷阱？

Answer 1

我发现的一个问题是两个对象包含彼此的引用（一个例子是父/子关系，在父对象上使用一种方便的方法来获取所有子对象）。
例如，在进行 Hibernate 映射时，此类事情相当常见。

如果您在 hashCode 或 equals 测试中包含关系的两端，则可能会进入以 StackOverflowException 结束的递归循环。
最简单的解决方案是不在方法中包含 getChildren 集合。

Answer 2

逻辑上我们有：

a.getClass().equals(b.getClass()) && a.equals(b) ⇒ a.hashCode() == b.hashCode()

但不反之亦然！

Answer 3

仍然令人惊讶的是没有人为此推荐番石榴库。

 //Sample taken from a current working project of mine just to illustrate the idea

    @Override
    public int hashCode(){
        return Objects.hashCode(this.getDate(), this.datePattern);
    }

    @Override
    public boolean equals(Object obj){
        if ( ! obj instanceof DateAndPattern ) {
            return false;
        }
        return Objects.equal(((DateAndPattern)obj).getDate(), this.getDate())
                && Objects.equal(((DateAndPattern)obj).getDate(), this.getDatePattern());
    }

Answer 4

超类 java.lang.Object 中有两个方法。 我们需要将它们重写为自定义对象。

public boolean equals(Object obj)
public int hashCode()

只要它们相等，相等的对象就必须产生相同的哈希码，但是不相等的对象不需要产生不同的哈希码。

public class Test
{
    private int num;
    private String data;
    public boolean equals(Object obj)
    {
        if(this == obj)
            return true;
        if((obj == null) || (obj.getClass() != this.getClass()))
            return false;
        // object must be Test at this point
        Test test = (Test)obj;
        return num == test.num &&
        (data == test.data || (data != null && data.equals(test.data)));
    }

    public int hashCode()
    {
        int hash = 7;
        hash = 31 * hash + num;
        hash = 31 * hash + (null == data ? 0 : data.hashCode());
        return hash;
    }

    // other methods
}

如果您想了解更多信息，请检查此链接 http://www.javaranch。 com/journal/2002/10/equalhash.html

这是另一个例子，
http://java67.blogspot .com/2013/04/example-of-overriding-equals-hashcode-compareTo-java-method.html

玩得开心！ @.@

Answer 5

在检查成员相等性之前，有几种方法可以检查类相等性，我认为这两种方法在适当的情况下都很有用。

1. 使用 instanceof 运算符。
2. 使用 this.getClass().equals(that.getClass()) 。

我在 final equals 实现中使用#1，或者在实现规定 equals 算法的接口时使用#1（例如 java.util 集合接口 - 检查的正确方法）与 (obj instanceof Set) 或您正在实现的任何接口）。 当 equals 可以被覆盖时，这通常是一个糟糕的选择，因为这会破坏对称性。

选项 #2 允许安全地扩展类，而不会覆盖 equals 或破坏对称性。

如果您的类也是Comparable，则equals 和compareTo 方法也应该一致。 以下是 Comparable 类中 equals 方法的模板：

final class MyClass implements Comparable<MyClass>
{

  …

  @Override
  public boolean equals(Object obj)
  {
    /* If compareTo and equals aren't final, we should check with getClass instead. */
    if (!(obj instanceof MyClass)) 
      return false;
    return compareTo((MyClass) obj) == 0;
  }

}

Answer 6

对于平等，请查看平等的秘密作者：安吉莉卡·兰格。 我非常爱它。 她还是一个关于Java 泛型的精彩常见问题解答。 此处查看她的其他文章（向下滚动到“Core Java”），她在其中还继续第 2 部分和“混合类型比较”。 祝您阅读愉快！

Answer 7

equals()方法用于判断两个对象是否相等。

因为 int 值 10 始终等于 10。但是这个 equals() 方法是关于两个对象相等的。 当我们说对象时，它就会有属性。 为了决定平等，需要考虑这些属性。 不必考虑所有属性来确定相等性，并且可以根据类定义和上下文来决定。 然后可以重写 equals() 方法。

每当我们重写 equals() 方法时，我们都应该重写 hashCode() 方法。 如果没有，会发生什么？ 如果我们在应用程序中使用哈希表，它将不会按预期运行。 由于 hashCode 用于确定存储的值的相等性，因此它不会返回键的正确对应值。

给出的默认实现是 Object 类中的 hashCode() 方法，使用对象的内部地址并将其转换为整数并返回。

public class Tiger {
  private String color;
  private String stripePattern;
  private int height;

  @Override
  public boolean equals(Object object) {
    boolean result = false;
    if (object == null || object.getClass() != getClass()) {
      result = false;
    } else {
      Tiger tiger = (Tiger) object;
      if (this.color == tiger.getColor()
          && this.stripePattern == tiger.getStripePattern()) {
        result = true;
      }
    }
    return result;
  }

  // just omitted null checks
  @Override
  public int hashCode() {
    int hash = 3;
    hash = 7 * hash + this.color.hashCode();
    hash = 7 * hash + this.stripePattern.hashCode();
    return hash;
  }

  public static void main(String args[]) {
    Tiger bengalTiger1 = new Tiger("Yellow", "Dense", 3);
    Tiger bengalTiger2 = new Tiger("Yellow", "Dense", 2);
    Tiger siberianTiger = new Tiger("White", "Sparse", 4);
    System.out.println("bengalTiger1 and bengalTiger2: "
        + bengalTiger1.equals(bengalTiger2));
    System.out.println("bengalTiger1 and siberianTiger: "
        + bengalTiger1.equals(siberianTiger));

    System.out.println("bengalTiger1 hashCode: " + bengalTiger1.hashCode());
    System.out.println("bengalTiger2 hashCode: " + bengalTiger2.hashCode());
    System.out.println("siberianTiger hashCode: "
        + siberianTiger.hashCode());
  }

  public String getColor() {
    return color;
  }

  public String getStripePattern() {
    return stripePattern;
  }

  public Tiger(String color, String stripePattern, int height) {
    this.color = color;
    this.stripePattern = stripePattern;
    this.height = height;

  }
}

示例代码输出：

bengalTiger1 and bengalTiger2: true 
bengalTiger1 and siberianTiger: false 
bengalTiger1 hashCode: 1398212510 
bengalTiger2 hashCode: 1398212510 
siberianTiger hashCode: –1227465966

Answer 8

关于 obj.getClass() != getClass() 的说明。

该语句是 equals() 继承不友好的结果。 JLS（Java 语言规范）规定，如果 A.equals(B) == true 则 B.equals(A) 也必须返回 true。 如果您忽略该语句，则继承重写 equals() 的类（并更改其行为）将违反此规范。

考虑以下示例，说明省略该语句时会发生什么：

    class A {
      int field1;

      A(int field1) {
        this.field1 = field1;
      }

      public boolean equals(Object other) {
        return (other != null && other instanceof A && ((A) other).field1 == field1);
      }
    }

    class B extends A {
        int field2;

        B(int field1, int field2) {
            super(field1);
            this.field2 = field2;
        }

        public boolean equals(Object other) {
            return (other != null && other instanceof B && ((B)other).field2 == field2 && super.equals(other));
        }
    }    

执行 new A(1).equals(new A(1)) 另外，new B(1,1).equals( new B(1,1)) 结果给出 true，正如它应该的那样。

这看起来非常好，但是看看如果我们尝试使用这两个类会发生什么：

A a = new A(1);
B b = new B(1,1);
a.equals(b) == true;
b.equals(a) == false;

显然，这是错误的。

如果要保证对称条件。 a=b 如果 b=a 并且里氏替换原则不仅在 B 实例的情况下调用 super.equals(other)，而且在之后检查 A 实例：

if (other instanceof B )
   return (other != null && ((B)other).field2 == field2 && super.equals(other)); 
if (other instanceof A) return super.equals(other); 
   else return false;

将输出：

a.equals(b) == true;
b.equals(a) == true;

其中，如果 a 不是 B 的引用，那么它可能是类 A< 的引用/code> （因为您扩展了它），在这种情况下您调用 super.equals() too。

Answer 9

如果您正在处理使用像 Hibernate 这样的对象关系映射器 (ORM) 持久化的类，并且您不认为这已经变得不合理的复杂，那么有一些问题值得注意！

延迟加载的对象是子类

如果您的对象使用 ORM 进行持久化，则在许多情况下您将处理动态代理以避免过早从数据存储中加载对象。 这些代理作为您自己的类的子类来实现。 这意味着 this.getClass() == o.getClass() 将返回 false。 例如：

Person saved = new Person("John Doe");
Long key = dao.save(saved);
dao.flush();
Person retrieved = dao.retrieve(key);
saved.getClass().equals(retrieved.getClass()); // Will return false if Person is loaded lazy

如果您正在处理 ORM，则使用 o instanceof Person 是唯一能够正确运行的方法。

延迟加载的对象具有空字段< ORM

通常使用 getter 来强制加载延迟加载的对象。 这意味着如果 person 延迟加载，person.name 将为 null，即使 person.getName()强制加载并返回“John Doe”。 根据我的经验，这种情况在 hashCode() 和 equals() 中更常见。

如果您正在处理 ORM，请确保始终使用 getter，并且切勿在 hashCode() 和 equals() 中使用字段引用。

保存对象将改变其状态

持久对象通常使用id字段来保存对象的键。 首次保存对象时，此字段将自动更新。 不要在 hashCode() 中使用 id 字段。 但您可以在 equals() 中使用它。

我经常使用的模式是

if (this.getId() == null) {
    return this == other;
}
else {
    return this.getId().equals(other.getId());
}

但是：您不能在 hashCode() 中包含 getId()。 如果这样做，当对象被持久化时，它的 hashCode 会发生变化。 如果该对象位于 HashSet 中，您将“永远”不会再找到它。

在我的 Person 示例中，我可能会使用 getName() 来表示 hashCode 和 getId() 以及 getName()（只是出于偏执）用于 equals()。 如果 hashCode() 存在一些“冲突”风险，那是可以的，但对于 equals() 则绝对不行。

hashCode() 应使用 equals() 中不变的属性子集

Answer 10

对于继承友好的实现，请查看 Tal Cohen 的解决方案，如何正确实现 equals() 方法？

摘要：

在他的书中 有效的 Java 编程语言指南（Addison-Wesley，2001 年），Joshua Bloch 声称“根本没有办法在保留 equals 契约的同时扩展可实例化类并添加方面。” 塔尔不同意。

他的解决方案是通过双向调用另一个非对称的blindlyEquals()来实现equals()。 blindlyEquals() 被子类重写，equals() 被继承，并且永远不会被重写。

示例：

class Point {
    private int x;
    private int y;
    protected boolean blindlyEquals(Object o) {
        if (!(o instanceof Point))
            return false;
        Point p = (Point)o;
        return (p.x == this.x && p.y == this.y);
    }
    public boolean equals(Object o) {
        return (this.blindlyEquals(o) && o.blindlyEquals(this));
    }
}

class ColorPoint extends Point {
    private Color c;
    protected boolean blindlyEquals(Object o) {
        if (!(o instanceof ColorPoint))
            return false;
        ColorPoint cp = (ColorPoint)o;
        return (super.blindlyEquals(cp) && 
        cp.color == this.color);
    }
}

请注意，如果要满足 里氏替换原则，则 equals() 必须跨继承层次结构工作。

Answer 11

理论（对于语言律师和数学爱好者）：

equals() (javadoc) 必须定义一个等价关系（它必须是自反、对称 和传递）。 此外，它必须一致（如果对象没有被修改，那么它必须保持返回相同的值）。 此外，o.equals(null) 必须始终返回 false。

hashCode() (javadoc) 也必须一致（如果对象没有根据 equals() 进行修改，则它必须保持返回相同的值）。

两种方法之间的关系是：

每当 a.equals(b) 时，a.hashCode() 必须与 b.hashCode() 相同.

实际上：

如果您覆盖其中一个，那么您应该覆盖另一个。

使用与计算 equals() 相同的字段集来计算 hashCode()。

使用优秀的帮助器类 EqualsBuilder< /a> 和 HashCodeBuilder 来自 Apache Commons Lang 库。 一个例子：

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

    @Override
    public int hashCode() {
        return new HashCodeBuilder(17, 31). // two randomly chosen prime numbers
            // if deriving: appendSuper(super.hashCode()).
            append(name).
            append(age).
            toHashCode();
    }

    @Override
    public boolean equals(Object obj) {
       if (!(obj instanceof Person))
            return false;
        if (obj == this)
            return true;

        Person rhs = (Person) obj;
        return new EqualsBuilder().
            // if deriving: appendSuper(super.equals(obj)).
            append(name, rhs.name).
            append(age, rhs.age).
            isEquals();
    }
}

还请记住：

当使用基于哈希的 集合或地图 例如HashSet，LinkedHashSet, HashMap, 哈希表，或 WeakHashMap，确保放入集合的关键对象的 hashCode() 在对象在集合中。 确保这一点的万无一失的方法是使您的密钥不可变，这还有其他好处< /a>.