К содержимому
Войти

Java Road Map

🟰 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:

  1. Рефлексивность: x.equals(x) всегда true
  2. Симметричность: если x.equals(y), то и y.equals(x)
  3. Транзитивность: если x равен y, а y равен z, то x равен z
  4. Согласованность: пока поля, участвующие в сравнении, не менялись, повторный вызов даёт тот же ответ
  5. 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 или хотя бы equals final. Наследник не может добавить поле в сравнение, симметрия держится. Так пишут большинство классов-значений
  • 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 печатает все компоненты, включая пароль, если он там есть

📚 Что почитать