Какие проблемы следует учитывать при переопределении equals и hashCode в Java?
Какие проблемы / подводные камни следует учитывать при переопределении equals а также hashCode?
11 ответов
Теория (для языковых юристов и математически склонных):
equals() ( javadoc) должен определять отношение эквивалентности (оно должно быть рефлексивным, симметричным и транзитивным). Кроме того, он должен быть согласованным (если объекты не изменены, он должен продолжать возвращать одно и то же значение). Более того, o.equals(null) всегда должен возвращать false.
hashCode() ( Javadoc) также должен быть согласованным (если объект не изменен с точки зрения equals(), он должен продолжать возвращать одно и то же значение).
Соотношение между этими двумя методами:
Всякий раз, когда
a.equals(b), затемa.hashCode()должен быть таким же, какb.hashCode(),
На практике:
Если вы переопределяете одно, то вы должны переопределить другое.
Используйте тот же набор полей, который вы используете для вычисления equals() вычислить hashCode(),
Используйте отличные вспомогательные классы EqualsBuilder и 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, Hashtable или WeakHashMap, убедитесь, что hashCode() ключевых объектов, которые вы помещаете в коллекцию, никогда не изменяется, пока объект находится в коллекции. Пуленепробиваемый способ обеспечить это - сделать ваши ключи неизменяемыми, что имеет и другие преимущества.
Есть некоторые проблемы, на которые стоит обратить внимание, если вы имеете дело с классами, которые сохраняются с использованием Object-Relationship Mapper (ORM), например Hibernate, если вы не думали, что это уже было неоправданно сложно!
Ленивые загруженные объекты являются подклассами
Если ваши объекты сохраняются с помощью 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 обычно используют геттеры для принудительной загрузки лениво загруженных объектов. Это означает, что person.name будет null если person лениво грузится, даже если person.getName() форсирует загрузку и возвращает "John Doe". По моему опыту, это чаще возникает в hashCode() а также equals(),
Если вы имеете дело с ORM, убедитесь, что всегда используете геттеры, и никогда не указывайте в hashCode() а также equals() ,
Сохранение объекта изменит его состояние
Постоянные объекты часто используют id поле для хранения ключа объекта. Это поле будет автоматически обновляться при первом сохранении объекта. Не используйте поле id в hashCode(), Но вы можете использовать его в equals(),
Шаблон, который я часто использую,
if (this.getId() == null) {
return this == other;
}
else {
return this.getId().equals(other.getId());
}
Но: вы не можете включить getId() в hashCode(), Если вы делаете, когда объект сохраняется, его hashCode изменения. Если объект находится в HashSet Вы никогда не найдете его снова.
В моем Person Например, я бы, наверное, использовал getName() за hashCode а также getId() плюс getName() (только для паранойи) для equals(), Это нормально, если есть некоторый риск "столкновений" для hashCode(), но никогда не в порядке для equals(),
hashCode() следует использовать неизменяемый набор свойств из equals()
Разъяснение о 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)) Результат выдают истину, как и положено.
Это выглядит очень хорошо, но посмотрите, что произойдет, если мы попробуем использовать оба класса:
A a = new A(1);
B b = new B(1,1);
a.equals(b) == true;
b.equals(a) == false;
Очевидно, это неправильно.
Если вы хотите обеспечить симметричное условие. a=b, если b=a и вызов принципа подстановки Лискова super.equals(other) не только в случае B экземпляр, но проверьте после 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 (потому что вы расширяете его), в этом случае вы звоните super.equals() тоже.
Для реализации, дружественной к наследованию, ознакомьтесь с решением Тэла Коэна " Как правильно реализовать метод equals ()"?
Резюме:
В своей книге " Эффективное руководство по языку программирования Java" (Addison-Wesley, 2001) Джошуа Блох утверждает, что "просто нет способа расширить инстанцируемый класс и добавить аспект при сохранении контракта равных". Тал не согласен.
Его решение состоит в том, чтобы реализовать equals (), вызывая другой несимметричный blindlyEquals () в обоих направлениях. 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 () должен работать в иерархиях наследования, если необходимо выполнить принцип подстановки Лискова.
Все еще поражен тем, что никто не рекомендовал библиотеку гуавы для этого.
//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());
}
В суперклассе есть два метода как 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
Повеселись! @.@
Есть несколько способов выполнить проверку на равенство классов перед проверкой равенства членов, и я думаю, что оба полезны в правильных обстоятельствах.
- Использовать
instanceofоператор. - использование
this.getClass().equals(that.getClass()),
Я использую № 1 в final равно реализации, или при реализации интерфейса, который предписывает алгоритм для равных (например, java.util интерфейсы коллекции - правильный способ проверки с помощью (obj instanceof Set) или какой-либо интерфейс вы реализуете). Обычно это плохой выбор, когда равенства могут быть переопределены, потому что это нарушает свойство симметрии.
Опция №2 позволяет безопасно расширять класс, не перекрывая равные и не нарушая симметрию.
Если ваш класс также Comparable, equals а также compareTo методы должны быть последовательными. Вот шаблон для метода equals в Comparable учебный класс:
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;
}
}
Для равных, посмотрите на Тайны Равных Анжеликой Лангер. Я очень люблю это. Она также является отличным FAQ по Generics в Java. Посмотрите ее другие статьи здесь (прокрутите вниз до "Базовая Java"), где она также продолжает Часть 2 и "Сравнение смешанных типов". Приятного чтения!
Метод equals() используется для определения равенства двух объектов.
так как int значение 10 всегда равно 10. Но этот метод equals() касается равенства двух объектов. Когда мы говорим объект, он будет иметь свойства. Чтобы решить вопрос равенства, рассматриваются эти свойства. Нет необходимости, чтобы все свойства были приняты во внимание, чтобы определить равенство, и в отношении определения класса и контекста это может быть решено. Тогда метод equals() может быть переопределен.
мы должны всегда переопределять метод hashCode() всякий раз, когда переопределяем метод equals(). Если нет, что будет? Если мы используем хеш-таблицы в нашем приложении, оно будет работать не так, как ожидалось. Поскольку hashCode используется для определения равенства хранимых значений, он не будет возвращать правильное соответствующее значение для ключа.
В качестве реализации по умолчанию используется метод hashCode() класса Object, который использует внутренний адрес объекта, преобразует его в целое число и возвращает его.
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
По логике мы имеем:
a.getClass().equals(b.getClass()) && a.equals(b) ⇒ a.hashCode() == b.hashCode()
Но не наоборот!
Я обнаружил одну ошибку: два объекта содержат ссылки друг на друга (один пример - отношения родитель / потомок с удобным методом для родителя, чтобы получить всех детей).
Такого рода вещи довольно распространены, например, при отображении в Hibernate.
Если вы включите оба конца отношения в свой hashCode или в тесты equals, можно попасть в рекурсивный цикл, который заканчивается в исключении StackruException.
Самое простое решение - не включать коллекцию getChildren в методы.