🟰 equals, hashCode и методы Object
Каждый класс в Java наследует Object, а с ним equals, hashCode, toString и ещё несколько методов. На работе от этих двух методов зависит, найдёт ли HashMap твой ключ и не появятся ли в HashSet дубли. На собеседовании контракт equals и hashCode спрашивают почти всегда, и ждут не пять свойств по списку, а объяснение, что именно сломается в коллекции и почему
🧠 Как это устроено
Методы Object
У Object нет полей, только методы. Их одиннадцать, если считать три перегрузки wait:
| Метод | Что делает |
|---|---|
equals(Object) | По умолчанию сравнивает ссылки, то есть ведёт себя как == |
hashCode() | Число для хэш-таблиц. По умолчанию своё у каждого объекта и не зависит от полей |
toString() | По умолчанию имя класса, @ и хэш в шестнадцатеричном виде: User@1b6d3586 |
getClass() | Класс объекта во время выполнения. final, переопределить нельзя |
clone() | Поверхностная копия, protected. Работает, только если класс помечен Cloneable |
finalize() | Вызывался перед сборкой мусора. Deprecated for removal с Java 18, подробнее — на странице про исключения |
wait, notify, notifyAll | Ожидание и пробуждение потоков на мониторе объекта, подробнее — в модуле многопоточности |
== сравнивает ссылки, equals сравнивает то, что автор класса назвал равенством. Почему == на строках и Integer иногда «работает», разобрано на странице про типы и строки
Контракт equals
Документация Object требует от equals пять свойств. Для любых не-null x, y, z:
- Рефлексивность:
x.equals(x)всегдаtrue - Симметричность: если
x.equals(y), то иy.equals(x) - Транзитивность: если
xравенy, аyравенz, тоxравенz - Согласованность: пока поля, участвующие в сравнении, не менялись, повторный вызов даёт тот же ответ
x.equals(null)возвращаетfalse, а не бросаетNullPointerException
Нарушить первое и последнее трудно. На практике ломают симметричность и транзитивность, обычно через наследование
Контракт hashCode
Правило одно, и работает оно в одну сторону: равные по equals объекты обязаны давать одинаковый hashCode. Обратное неверно. Два разных объекта могут иметь один хэш, это коллизия, и хэш-таблица с ней справляется. Ещё hashCode должен быть стабильным, пока не менялись поля из equals, но между запусками программы значение может отличаться
Зачем это нужно, видно по тому, как HashMap ищет ключ. Сначала она считает hashCode и по нему выбирает корзину. Внутри корзины сравнивает сохранённый хэш, и только если он совпал, вызывает equals. Если два равных объекта дают разные хэши, до equals дело не дойдёт: таблица посмотрит не в ту корзину или отбросит кандидата по хэшу. Как корзины устроены изнутри, разобрано на странице про HashMap в модуле коллекций
🛠️ На практике
Переопределили только один метод
Два класса с одним полем email. В первом есть только equals, во втором только hashCode:
import java.util.*;
public class Main {
static final class OnlyEquals {
final String email;
OnlyEquals(String email) { this.email = email; }
@Override public boolean equals(Object o) {
return o instanceof OnlyEquals other && email.equals(other.email);
}
}
static final class OnlyHash {
final String email;
OnlyHash(String email) { this.email = email; }
@Override public int hashCode() { return email.hashCode(); }
}
public static void main(String[] args) {
Set<OnlyEquals> a = new HashSet<>();
a.add(new OnlyEquals("ann@mail.ru"));
a.add(new OnlyEquals("ann@mail.ru"));
System.out.println("только equals, размер: " + a.size());
Map<OnlyEquals, String> m = new HashMap<>();
m.put(new OnlyEquals("ann@mail.ru"), "Анна");
System.out.println("только equals, get: " + m.get(new OnlyEquals("ann@mail.ru")));
Set<OnlyHash> b = new HashSet<>();
b.add(new OnlyHash("ann@mail.ru"));
b.add(new OnlyHash("ann@mail.ru"));
System.out.println("только hashCode, размер: " + b.size());
System.out.println("только hashCode, contains: " + b.contains(new OnlyHash("ann@mail.ru")));
}
}Вывод на JDK 19:
только equals, размер: 2
только equals, get: null
только hashCode, размер: 2
только hashCode, contains: falseС одним equals объекты равны, но хэши у них от Object, разные. HashSet кладёт копии в разные корзины и хранит дубль, а get с новым, равным ключом возвращает null. С одним hashCode объекты попадают в одну корзину, но equals от Object сравнивает ссылки, и таблица снова считает их разными. Ломаются оба варианта, просто по-разному: в первом таблица ищет не там, во втором находит, но не узнаёт
Как писать equals
Обычная форма с pattern matching для instanceof, он финальный с Java 16:
public final class User {
private final String email;
private final String name;
@Override
public boolean equals(Object o) {
if (this == o) return true;
return o instanceof User other
&& Objects.equals(email, other.email)
&& Objects.equals(name, other.name);
}
@Override
public int hashCode() {
return Objects.hash(email, name);
}
}instanceof сам возвращает false для null, так что пятое свойство выполняется без отдельной проверки. Objects.equals(a, b) не падает, если поле null. Objects.hash собирает хэш из нескольких полей, но создаёт массив на каждый вызов. В горячем коде вроде ключа большой мапы его иногда заменяют на ручное 31 * h + field.hashCode(). В hashCode идут ровно те поля, что и в equals, или их часть, но никогда поле, которого в equals нет
Для класса-значения проще взять record. Компилятор сам выводит equals, hashCode и toString из всех компонентов:
record Money(long amount, String currency) {}
new Money(100, "RUB").equals(new Money(100, "RUB")) // true
new Money(100, "RUB").toString() // Money[amount=100, currency=RUB]Компоненты-массивы record сравнивает по ссылке, как любой equals по умолчанию. record Token(char[] value) с двумя одинаковыми массивами даст false
instanceof против getClass
Выбор проверки решает, что будет с наследниками. Пусть Point сравнивает x и y через instanceof, а наследник ColorPoint добавил поле color и сравнивает ещё и его:
Point p = new Point(1, 2);
ColorPoint cp = new ColorPoint(1, 2, "red");
System.out.println(p.equals(cp)); // true: cp — тоже Point
System.out.println(cp.equals(p)); // false: p — не ColorPointСимметричность нарушена. HashSet с такими объектами ведёт себя по-разному в зависимости от того, кого положили первым
Есть два честных выхода:
instanceofи запрет наследования. Классfinalили хотя быequalsfinal. Наследник не может добавить поле в сравнение, симметрия держится. Так пишут большинство классов-значенийgetClass() != o.getClass(). Объекты разных классов никогда не равны, симметрия держится и с наследниками. Цена: наследник без новых полей тоже не равен родителю. Это нарушает принцип подстановки Лисков и бьёт по прокси, которые Hibernate и Spring создают как подклассы
Добавить поле в наследнике и сохранить контракт equals нельзя ни одним из способов. Если такое нужно, наследование меняют на композицию: ColorPoint хранит Point полем
Изменяемые поля в hashCode
HashSet запоминает корзину в момент add. Если потом поменять поле, от которого зависит хэш, объект останется в старой корзине, а искать его будут в новой:
Set<User> users = new HashSet<>();
User ann = new User("ann@mail.ru"); // email изменяемый, участвует в hashCode
users.add(ann);
ann.email = "ann@yandex.ru";
System.out.println(users.contains(ann)); // false
users.add(ann);
System.out.println(users.size()); // 2 — один и тот же объект дваждыОбъект есть в множестве, но ни найти, ни удалить его через remove уже нельзя. Поэтому ключи мап и элементы множеств делают неизменяемыми. Что происходит с ключом HashMap при изменении, подробно разобрано на странице про HashMap в модуле коллекций
equals у JPA-сущностей
Сущности ломают оба привычных подхода. Сравнение по всем полям не годится: поля меняются, пока сущность лежит в Set, а ленивые связи при обращении из equals поднимают запросы к базе или бросают LazyInitializationException. Сравнение по сгенерированному id в лоб тоже ломается: до persist id равен null, все новые сущности либо равны друг другу, либо хэш меняется после сохранения, и объект теряется в множестве. Обычно сравнивают по натуральному ключу вроде email или по id с постоянным hashCode и проверкой на null. Разбор вариантов — в модуле работы с базой из Java
toString
По умолчанию toString печатает User@1b6d3586, и в логе это ничего не говорит. Переопределяй его у всего, что попадает в логи и сообщения исключений: доменные объекты, DTO, события. Record делает это сам
Обратная сторона: toString от record или Lombok @ToString печатает все поля. Пароль, токен или номер карты в записи о входе пользователя окажется в логах, а оттуда в системе сбора логов. Чувствительные поля исключай явно или переопределяй toString у такого record вручную
clone и почему его избегают
Cloneable — интерфейс-маркер без методов. Он только разрешает Object.clone() работать, иначе тот бросает CloneNotSupportedException. Сам clone у Object protected, поэтому его ещё надо переопределить публичным. И копия получается поверхностной:
Order a = new Order();
a.items.add("кофе");
Order b = a.clone(); // super.clone() внутри
b.items.add("круассан");
System.out.println(a.items); // [кофе, круассан]
System.out.println(a.items == b.items); // true — список общийГлубокую копию придётся писать руками, а final-поля в clone не переприсвоить. Вместо этого делают конструктор копирования new Order(other) или фабрику Order.copyOf(other): видно, что копируется, и final работает. Для массивов clone по-прежнему нормальный способ, там он публичный и без исключений
⚠️ Где ошибаются
- Переопределяют
equalsи забываютhashCode. Тесты наequalsзелёные, а дубли всплывают вHashSetна проде. IDE и Lombok@EqualsAndHashCodeгенерируют оба метода сразу, руками пиши тоже парой - Пишут
equals(User other)вместоequals(Object o). Это перегрузка, а не переопределение. Коллекции вызываютequals(Object)отObject, и твой метод никто не вызовет.@Overrideна таком методе даст ошибку компиляции, поэтому его не пропускают - Кладут в
hashCodeизменяемое поле, а объект держат вHashSetили как ключHashMap. После изменения поля объект становится невидимым для коллекции - Вешают
@Dataили@EqualsAndHashCodeна JPA-сущность. Lombok сравнит все поля, включая ленивые связи, иtoStringс двусторонней связью уйдёт в бесконечную рекурсию соStackOverflowError - Сравнивают массивы через
equals.new int[]{1, 2}.equals(new int[]{1, 2})даётfalse, нуженArrays.equals, для вложенных массивовArrays.deepEquals
🎯 Вопросы с собеседований
Какие методы есть у класса Object?
equals и hashCode для сравнения и хэш-таблиц, toString для текстового представления, getClass для класса во время выполнения. clone делает поверхностную копию и требует Cloneable. wait, notify, notifyAll работают с монитором объекта в многопоточном коде, они final. finalize вызывался перед сборкой мусора, с Java 18 он deprecated for removal, вместо него try-with-resources и Cleaner
Какой контракт у equals и hashCode? Что будет, если переопределить только один?
equals должен быть рефлексивным, симметричным, транзитивным, согласованным, а x.equals(null) возвращает false. Равные по equals объекты обязаны иметь одинаковый hashCode, обратное не требуется. Если переопределить только equals, хэши остаются от Object: HashSet хранит дубли, а HashMap.get с равным ключом возвращает null, потому что ищет в другой корзине. Если только hashCode, объекты попадают в одну корзину, но equals сравнивает ссылки, и результат тот же: дубли и промахи
Чем getClass в equals отличается от instanceof?
instanceof считает наследника равным родителю, если совпали поля родителя. Как только наследник добавляет поле в сравнение, ломается симметричность: point.equals(colorPoint) даёт true, обратный вызов false. getClass запрещает равенство объектов разных классов, симметрия сохраняется, но наследник без новых полей и прокси Hibernate перестают быть равны оригиналу. Поэтому для классов-значений берут instanceof и делают класс final
Может ли hashCode всегда возвращать 1? Что будет?
Может, контракт соблюдён: равные объекты дают равные хэши. Но все ключи попадут в одну корзину, и HashMap превратится в список. С Java 8 переполненная корзина перестраивается в красно-чёрное дерево, но упорядочить узлы оно может только по compareTo. Если ключ не Comparable, дерево не помогает, и get обходит узлы почти подряд. В замере на JDK 19 со ста тысячами ключей такой поиск оказался в тысячи раз медленнее, чем с нормальным hashCode, а с Comparable-ключом отставал всего в несколько раз
Почему ключ HashMap лучше делать неизменяемым?
Корзина выбирается по hashCode в момент put и потом не пересчитывается. Если поле, от которого зависит хэш, изменилось, get и containsKey ищут в новой корзине, а запись лежит в старой. Запись остаётся в мапе, занимает память, видна при обходе, но найти или удалить её по ключу нельзя. Неизменяемый ключ вроде String, Integer или record с неизменяемыми полями этой проблемы не имеет
Как record реализует equals и hashCode и где он может подвести?
Компилятор генерирует equals, hashCode и toString по всем компонентам: два record равны, если равны все компоненты. Алгоритм хэша документация не фиксирует, полагаться на конкретное число нельзя. Подводят два случая. Компонент-массив сравнивается по ссылке, так что record с одинаковыми массивами не равны. И toString печатает все компоненты, включая пароль, если он там есть
📚 Что почитать
- Object в документации Java 25 — контракты
equalsиhashCodeв формулировке авторов языка, их и цитируют на собеседованиях - Objects в документации Java 25 —
equals,hash,requireNonNullи другие помощники, которые экономят проверки наnull - Records на dev.java — что компилятор генерирует для record и как добавить в него свою проверку или метод
- JEP 394: Pattern Matching for instanceof — откуда взялась форма
o instanceof User otherи с какой версии она финальная