❓ Расскажите про иерархию исключений

В Java иерархия исключений начинается от класса Throwable, который делится на две ветки:

🔹 Error — критические ошибки JVM, например OutOfMemoryError. Их не обрабатывают, так как это сбои среды выполнения.
🔹 Exception — обрабатываемые ошибки приложения.

Внутри Exception выделяют:

🔹 Checked exceptions — наследники Exception. Проверяются во время компиляции. Требуют try-catch или throws. Пример: IOException, SQLException.
🔹 Unchecked exceptions — наследники RuntimeException. Возникают из-за ошибок в логике программы, проверка компилятором не требуется. Пример: NullPointerException, IndexOutOfBoundsException.

🐸 Библиотека собеса по Java

#core

❓ В чём разница между Statement и PreparedStatement?

— Statement используется для выполнения простых SQL-запросов без параметров. Он формирует запрос как строку и каждый раз компилирует его заново, что может быть медленно и небезопасно.

— PreparedStatement предварительно компилируется базой данных и позволяет задавать параметры через плейсхолдеры. Что повышает производительность при многократном выполнении одного запроса и защищает от SQL-инъекций (данные не конкатенируются со строкой запроса, а подставляются корректно).

Поэтому в реальных проектах почти всегда используют PreparedStatement.

🐸 Библиотека собеса по Java

#core

❓ Что такое денормализация в базах данных?

Денормализация — это процесс преднамеренного добавления избыточности в структуру базы данных для повышения производительности чтения. В отличие от нормализации, цель которой — устранить дублирование и обеспечить целостность, денормализация может включать дублирование данных, объединение таблиц или добавление агрегированных колонок.

🐸 Библиотека собеса по Java

#core

❓ В чём разница между IO и NIO?

IO (Input/Output) — это традиционная модель потоков, использующая блокирующие операции для чтения и записи данных, что может привести к задержкам, если операция занимает много времени.

NIO (New IO) был введён в JDK 1.4 для улучшения производительности, предлагая неблокирующие каналы и буферы, а также поддержку асинхронных операций, что позволяет эффективно работать с большими объёмами данных или многими соединениями одновременно.

🐸 Библиотека собеса по Java

#core

❓ Что такое идемпотентность в REST API?

Идемпотентность означает, что повторный вызов одного и того же запроса не изменяет состояние сервера более одного раза.

Способы реализации:

— Использовать контроль состояния (если запись уже существует, не создавать её второй раз).

— Использовать HTTP методы по стандарту: GET, PUT, DELETE. Уже идемпотентны по спецификации.

— Использовать уникальный ключ (идемпотентный токен) с клиентской стороны; сервер хранит, что уже получал этот токен, и при повторе не выполняет операцию заново.

— В Spring → фильтры или interceptors проверяют заголовок Idempotency-Key и используют хранилище (БД, кеш) для управления повторными запросами.

🐸 Библиотека собеса по Java

#core

❓ Для чего используется ключевое слово this?

this — это ссылка на текущий объект внутри его метода или конструктора. Оно нужно для:

— Разрешения конфликта имён (например, между полем класса и параметром метода).
— Вызова других конструкторов этого же класса.
— Передачи текущего объекта в качестве аргумента в методы или конструкторы других классов.
— Возврата ссылки на текущий объект (часто используется в паттерне Builder или для чейнинга методов).

🐸 Библиотека собеса по Java

#core

❓ Что такое наследование?

Наследование — это механизм ООП, позволяющий создавать новый класс на основе уже существующего. Новый класс (подкласс) получает все свойства и методы родительского класса (суперкласса), что обеспечивает повторное использование кода и упрощает поддержку.

Наследование реализуется с помощью ключевого слова extends. Подкласс может расширять или переопределять поведение суперкласса, а также добавлять новые поля и методы. Важно помнить, что в Java класс может наследоваться только от одного суперкласса.

🐸 Библиотека собеса по Java

#core

❓ Можно ли изменить значение final переменной через рефлексию?

Технически можно, но это нарушает контракт final и приводит к непредсказуемому поведению.

Field field = obj.getClass().getDeclaredField("finalField");
field.setAccessible(true);
field.set(obj, newValue);  // может не сработать

Проблемы

— JVM может заинлайнить final значение при компиляции
— изменения могут не отразиться из-за оптимизаций
— нарушается thread-safety гарантия final

🐸 Библиотека собеса по Java

#core

❓ Что такое Optional и когда его НЕ стоит использовать?

Optional<T> — контейнер, который явно сигнализирует об отсутствии значения вместо null.

Не стоит использовать

— В полях класса (не сериализуется хорошо)
— В параметрах методов (лучше перегрузка)
— В Collections (List<Optional<T>> — антипаттерн)

Стоит использовать: как возвращаемый тип, когда значение действительно может отсутствовать.

🐸 Библиотека собеса по Java

#core

❓ Как работает G1 GC?

G1 делит heap на равные регионы (~2048 штук) вместо фиксированных Young/Old/Perm зон. Каждый регион динамически назначается как Eden, Survivor или Old.

Ключевые фазы

→ Initial Mark — STW, помечает GC roots
→ Concurrent Mark — параллельно с приложением строит граф достижимости
→ Remark — STW, дочищает concurrent-фазу (SATB-алгоритм)
→ Cleanup / Evacuation — копирует живые объекты из регионов с наибольшим мусором (отсюда "Garbage First")

🐸 Библиотека собеса по Java

#core

❓ Что такое иммутабельный объект?

Иммутабельный объект — это объект, состояние которого невозможно изменить после его создания.  Иммутабельность способствует безопасности потоков и предотвращению ошибок, связанных с изменениями состояния объектов. Примером может служить класс String.

🤖 Осталось 4 места на курс по ИИ-агентам. Набор закрывается 30 апреля.
🔗 Успеть на обучение

🐸 Библиотека собеса по Java

#core

❓ Как работает HashMap внутри? Что происходит при коллизии и при достижении load factor?

HashMap — массив бакетов (Node[] table). Ключ хешируется, хеш определяет индекс бакета: index = hash & (capacity - 1

Что происходит при put(key, value):

Считается hash(key) — не просто hashCode(), а с дополнительным перемешиванием старших битов ((h = key.hashCode()) ^ (h >>> 16)). Это снижает коллизии при маленьком размере таблицы.

Находится бакет по индексу. Если пустой — кладём первым. Если нет — коллизия.

🔹 Коллизия:

До Java 8 → связный список в бакете. Поиск O(n) в худшем случае.

С Java 8 → когда в бакете больше 8 элементов и capacity >= 64, список превращается в красно-чёрное дерево. Поиск становится O(log n). Обратно в список — при сжатии ниже 6 элементов.

// Упрощённо: Node в списке или TreeNode в дереве
static class Node<K,V> {
    final int hash;
    final K key;
    V value;
    Node<K,V> next;
}

🔹 Load factor и resize:

По умолчанию capacity = 16, loadFactor = 0.75. Порог = capacity * loadFactor = 12.

Как только элементов стало больше 12 — начинается resize(): таблица удваивается до 32, все элементы перераспределяются по новым бакетам. Это O(n) операция.

Поэтому если заранее знаете размер — задавайте начальную ёмкость:

// Хотим 1000 элементов без resize:
// 1000 / 0.75 ≈ 1334, берём следующую степень двойки
Map<String, Integer> map = new HashMap<>(2048);

🐸 Библиотека собеса по Java

#core

❓ Что происходит с объектом, когда на него не осталось ссылок?

Объект становится кандидатом на сборку мусора, но память освобождается не сразу.

GC ориентируется на достижимость от GC roots (стек потоков, статические поля, JNI-ссылки, активные локальные переменные). Пока объект достижим хотя бы по одной цепочке — он живой. Как только он перестаёт быть достижимым, он помечается недостижимым и память освобождается при ближайшем цикле сборки.

Если у объекта есть finalize() или он зарегистрирован в Cleaner/PhantomReference, освобождение откладывается на дополнительный цикл.

🐸 Библиотека собеса по Java

#core

❓ Возможна ли утечка памяти, несмотря на сборщик мусора?

Да, возможна. GC удаляет только недостижимые объекты. Утечка — это когда объекты остаются достижимыми, но больше не нужны, и память не освобождается.

Типичные источники:

→ неограниченные кеши и статические коллекции (static Map), которые растут без удаления;
→ незакрытые ресурсы (соединения, стримы);
→ слушатели/колбэки без отписки;
→ ThreadLocal в пуле потоков, где значение не очищается через remove() (поток переиспользуется и не умирает);
→ утечка класслоадеров при горячей перезагрузке.

🐸 Библиотека собеса по Java

#core

❓ Что такое type erasure и какие ограничения он накладывает на дженерики?

generics дают типобезопасность на этапе компиляции, но в рантайме информация о типовых параметрах стирается: List<String> превращается в обычный List, а компилятор сам вставляет приведения типов. Сделано ради обратной совместимости со старым кодом.

Из-за стирания нельзя:

→ создать new T() или new T[];
→ использовать instanceof List<String>;
→ иметь статические поля типа T;
→ объявить два метода, отличающиеся только параметром типа (после стирания их сигнатуры совпадут).

Частичная информация о дженериках сохраняется в сигнатурах полей и методов и доступна через рефлексию, но не на уровне конкретных экземпляров.

🐸 Библиотека собеса по Java

#core

❓ Объясните правило PECS (Producer Extends, Consumer Super)?

Это правило выбора ограниченных wildcards в дженериках.

? extends T — ковариантность, структура-«производитель»: из неё можно безопасно читать как T, но нельзя добавлять элементы, потому что компилятор не знает точный подтип.

? super T — контравариантность, структура-«потребитель»: в неё можно безопасно добавлять T и его подтипы, но при чтении вернётся только Object.

Отсюда мнемоника: если коллекция только отдаёт данные (producer) → extends; если только принимает (consumer) → super.

🐸 Библиотека собеса по Java

#core

❓ Какой контракт связывает equals() и hashCode()?

Контракт: если два объекта равны по equals(), их hashCode() обязан быть одинаков. Обратное не требуется — равные хеши не означают равенство объектов (коллизии допустимы).

Если переопределить equals() и забыть про hashCode(), объект сломается в HashMap/HashSet: положили объект по одному хешу, ищем по другому, и не находим, хотя по equals() он равен.

Дополнительно equals() должен быть рефлексивным, симметричным, транзитивным и согласованным (не меняться без изменения полей).

🐸 Библиотека собеса по Java

#core

❓ ArrayList или LinkedList?

В подавляющем большинстве случаев → ArrayList.

ArrayList — это динамический массив: доступ по индексу O(1), вставка/удаление в середине O(n) из-за сдвига элементов. Но на практике он почти всегда быстрее за счёт локальности данных в памяти и дружбы с кешем процессора.

LinkedList — двусвязный список: вставка/удаление по уже найденной позиции O(1), но доступ по индексу O(n), и каждый элемент — отдельный объект с накладными расходами на ссылки.

LinkedList оправдан редко — например, когда нужен Deque с частыми вставками в оба конца. Для обычного списка берите ArrayList.

🐸 Библиотека собеса по Java

#core

❓ Чем отличаются HashMap, Hashtable и ConcurrentHashMap

HashMap — не потокобезопасен, разрешает один null-ключ и null-значения, самый быстрый в однопоточном коде.

Hashtable — legacy-класс, синхронизирован целиком: один лок на всю таблицу, поэтому в многопоточке работает медленно. Не допускает null.

ConcurrentHashMap — потокобезопасен с тонкой блокировкой: с Java 8 синхронизация идёт на уровне отдельного бакета через CAS и synchronized, что даёт высокую конкурентность. null не допускает (чтобы не путать «нет ключа» и «значение null» при гонках).

🐸 Библиотека собеса по Java

#core

❓ Чем fail-fast итераторы отличаются от fail-safe?

fail-fast (ArrayList, HashMap) бросают ConcurrentModificationException при структурном изменении коллекции во время обхода. Механизм — счётчик modCount, который итератор сверяет на каждом шаге. Это способ быстро отловить баг, а не средство защиты.

fail-safe (CopyOnWriteArrayList, ConcurrentHashMap) не бросают исключение:
- CopyOnWriteArrayList при модификации копирует внутренний массив, итератор работает со «снимком» старого состояния;
- итератор ConcurrentHashMap слабо-согласованный (weakly consistent) — отражает состояние на момент создания или позже, без жёстких гарантий.

Fail-safe безопасны в многопоточке, но итератор может не видеть свежие изменения и обходятся дороже по памяти.

🐸 Библиотека собеса по Java

#core