Вопросы на собеседовании Java junior

Четыре принципа: инкапсуляция, наследование, полиморфизм, абстракция — к каждому короткий пример.

== даст false, equals() — true: == сравнивает ссылки, equals() у String — содержимое.

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

a==b → true, c==d → false: Integer.valueOf() кэширует значения от −128 до 127.

Optional — контейнер «значение или пусто», который явно говорит, что результата может не быть, и заставляет это обработать.

final у ссылки запрещает переприсваивание, но объект по ней менять можно.

Куча (heap) — все объекты и массивы, общая для потоков, её чистит GC. Стек — у каждого потока свой: кадры вызовов с локальными переменными и ссылками. Metaspace — метаданные…

Вложенность: JVM исполняет байткод, JRE = JVM + стандартные библиотеки для запуска, JDK = JRE + инструменты разработки.

final-класс нельзя наследовать (String, Integer), final-метод нельзя переопределить, final-переменная или поле присваивается ровно один раз. final-ссылка не делает объект…

Сначала FileNotFoundException, затем IOException: catch проверяются сверху вниз, и общий тип перед частным делает частный недостижимым — ошибка компиляции.

Дженерики — проверка типов на компиляции без приведений вручную. Wildcard: ? extends T — из коллекции читают как T (производитель), ? super T — в коллекцию пишут T (потребитель)…

Thread — сам поток выполнения. Runnable — задача без результата (void run()), Callable<V> — задача с результатом V call(), которая может бросить проверяемое исключение.

Перегрузка (overloading) — несколько методов с одним именем и разными параметрами в одном классе; выбор на этапе компиляции по объявленным типам аргументов. Переопределение…

String неизменяем: каждая «правка» — новый объект. StringBuilder — изменяемый буфер, быстрый, не потокобезопасный. StringBuffer — то же, но с synchronized на каждом методе …

HashSet — без порядка, операции O(1); LinkedHashSet — помнит порядок вставки, O(1); TreeSet — отсортирован (красно-чёрное дерево), O(log n) и навигация: first, ceiling, subSet.

InputStreamReader декодирует байты в символы, OutputStreamWriter кодирует символы в байты. Кодировку указывают явно: new InputStreamReader(in, StandardCharsets.UTF_8).

Unit-тест проверяет единицу логики изолированно: быстро, без БД и сети, зависимости заменены моками. Интеграционный проверяет связку компонентов с реальной инфраструктурой: БД…

Проще всего — new StringBuilder(s).reverse().toString(); вручную — обмен символов массива с двух концов.

Примитивов восемь: byte, short, int, long, float, double, char, boolean; char — 16-битный беззнаковый, один UTF-16 code unit.

Integer.MIN_VALUE, без исключения: целочисленная арифметика молча заворачивается по модулю 2³². 2147483647 + 1 = −2147483648.

false: 0.1 непредставимо точно в двоичной плавающей точке (IEEE 754), сумма даёт 0.30000000000000004. Для денег — BigDecimal из строки (new BigDecimal("0.1")) или копейки в long.

NullPointerException: int y = x компилируется в x.intValue(), а вызов метода на null — NPE. Обёртка может быть null, примитив — нет.

Параметр дженерика может быть только ссылочным типом, поэтому пишут List<Integer> с автоупаковкой.

Функциональный интерфейс — интерфейс ровно с одним абстрактным методом (SAM); лямбда и ссылка на метод — его реализация.

var — статический вывод типа компилятором из инициализатора; тип фиксируется при компиляции, динамики нет.

java.time (Java 8) неизменяем, потокобезопасен и с явной моделью: Instant, LocalDate, LocalTime, ZonedDateTime, Duration, Period. Date и Calendar изменяемы, месяцы с нуля…

Неизменяемый объект потокобезопасен без синхронизации, безопасен как ключ Map / элемент Set и его можно свободно кэшировать и делить.

SRP: у модуля одна причина для изменения — он отвечает перед одним актором (группой заинтересованных людей).

Iterable → Collection → List, Set, Queue; Map — отдельная ветвь, не Collection: она хранит пары, а не элементы.

Ничего не произойдёт снаружи: Java всегда передаёт аргументы по значению, метод получает копию.

Интерфейсов — сколько угодно, класс-родитель — только один.

DRY — Don't Repeat Yourself: каждое знание (правило, расчёт) должно быть записано в одном месте.

List — упорядоченная последовательность с дубликатами и доступом по индексу; Set — только уникальные элементы.

В основе — массив, который при заполнении заменяется большим с копированием элементов (примерно в 1,5 раза).

O(n): произвольного доступа нет, до позиции нужно дойти по ссылкам (JDK начинает с ближнего конца).

По hashCode ключа вычисляется индекс корзины в массиве, внутри корзины ключи сравниваются через equals.

Предсказуемый порядок обхода — по умолчанию в порядке вставки — поверх той же хеш-таблицы.

Всегда в порядке сортировки ключей — по естественному порядку (Comparable) или по переданному компаратору.

Множество не изменится, а add вернёт false — удобная проверка «элемент новый?».

Очередь (FIFO) отдаёт элементы в порядке поступления, стек (LIFO) — начиная с последнего добавленного.

Iterator даёт единый способ обойти коллекцию, не раскрывая её устройства: hasNext() и next().

HashMap не потокобезопасен: параллельная запись ломает структуру — потерянные записи, неверный size, в старых версиях — зависание обхода.

Исключение поднимается вверх по стеку вызовов до первого подходящего catch; если его нет — поток завершается со стектрейсом.

try-with-resources гарантированно закрывает ресурсы при любом выходе из блока — без ручного finally.

start() создаёт новый поток, и уже он вызывает run(); прямой run() выполняется в текущем потоке, как обычный метод.

synchronized даёт взаимное исключение (один поток в блоке по данному монитору) и видимость изменений для следующего вошедшего.

AtomicInteger выполняет операции вроде инкремента атомарно без блокировок — на аппаратной инструкции CAS (сравнение с обменом).

unlock() — в finally, а lock() — перед try: иначе исключение в критической секции оставит замок захваченным навсегда.

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

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

CountDownLatch — защёлка на счётчике: потоки ждут в await(), пока другие не уменьшат счётчик до нуля через countDown().

ThreadLocal — своя ячейка значения для каждого потока: синхронизация не нужна, потому что значение никто не разделяет.

Виртуальный поток — лёгкий поток под управлением JVM, а не ОС: создание и блокировка стоят копейки, их можно держать миллионами.

Объекты — в куче, общей для всех потоков; в стеке потока — кадры вызовов с локальными переменными, в том числе ссылками на объекты.

Удаляются недостижимые от корней объекты: сборщик обходит граф ссылок от GC roots, всё, до чего не дошёл, — мусор.

Stop-the-world — все потоки приложения приостанавливаются, пока сборщик выполняет часть работы; эти паузы и стараются сокращать.

Слабая ссылка позволяет обратиться к объекту, но не удерживает его от сборки: если обычных ссылок нет, объект соберут.

Начинать с измерений: включить логи GC и понять, в чём проблема — длинные паузы, частые сборки или рост живых данных.

Проблема видимости: без синхронизации нет гарантии, что поток увидит изменение, сделанное другим, — нужен volatile или синхронизация.

Дженерики переносят проверку типов на этап компиляции и убирают ручные приведения при чтении.

List<?> — список неизвестного типа: читать можно как Object, добавлять нельзя ничего, кроме null.

Стирание типов: компилятор проверяет типы, но в байткоде параметр заменяется границей (обычно Object) — в рантайме его нет.

Stream — конвейер обработки элементов источника: данные не хранит и источник не меняет.

collect — терминальная операция, которая складывает результат конвейера в структуру: список, множество, карту, строку.

Вернётся новый объект, исходный не изменится — все типы java.time неизменяемы.

Байтовые потоки (InputStream/OutputStream) — для любых двоичных данных, символьные (Reader/Writer) — для текста и учитывают кодировку.

Buffer — область памяти фиксированного размера, через которую данные читаются из канала и пишутся в него.

Сериализация — преобразование объекта в байты для передачи или хранения и обратное восстановление.

Порождающие паттерны отделяют клиента от конкретных классов создаваемых объектов: создание прячут за фабрикой или билдером.

Структурные паттерны построены на композиции и делегировании: объект хранит ссылку на другой и пропускает вызовы через себя.

Поведенческие паттерны описывают, как объекты распределяют обязанности и взаимодействуют.

Уровни нужны, чтобы фильтровать записи по важности: в продакшене — только значимое, подробности — для отладки.

record — компактный неизменяемый носитель данных: поля в заголовке, а конструктор, аксессоры, equals, hashCode и toString создаёт компилятор.

sealed ограничивает список наследников: наследовать или реализовывать могут только перечисленные в permits типы.

JIT компилирует часто выполняемые участки байткода в машинный код прямо во время работы программы.

Тест — метод с @Test в классе в src/test/java. Проверки — assertEquals(ожидаемое, фактическое), assertTrue, assertThrows для исключений; удобнее — AssertJ…

Система сборки скачивает зависимости нужных версий из репозитория (Maven Central), компилирует код, запускает тесты и упаковывает результат (jar). Maven описывает проект…

Switch-выражение (Java 14) возвращает значение, использует стрелки case A -> ... без проваливания и требует покрыть все варианты (для enum и sealed — проверяет компилятор). Text…