Какие ключевые темы нужно знать Java-разработчику для собеседования?

Давай я тебе на пальцах, но с пиздой, объясню, что от тебя хотят на этих ваших собесах по джаве. Сядь, не дыши.

1. Ядро, блядь, Джава (Core Java)

• Многопоточность: Это когда твоя программа должна делать несколько дел сразу, как ты, сука, в телеге с тремя чатами сидишь. ExecutorService — это начальник, который раздаёт задачи рабам-потокам. Future — это бумажка с обещанием, что раб когда-нибудь принесёт результат, а пока ты ждёшь и ебёшь мозг. synchronized и ReentrantLock — это чтобы два потока не начали одновременно писать в одну переменную, а то получится пиздец и race condition, и все данные — в говне. volatile — это крик на всю деревню: «Смотрите сюда, значение изменилось, вы все, блядь, обновите его у себя в кэшах!».
• Коллекции: HashMap — это как шкаф с ящиками. Ключ — фамилия, значение — твоё говно. Хэш-функция решает, в какой ящик положить. Если два ключа претендуют на один ящик (коллизия) — там будет цепочка. ArrayList — это линейка, быстрая, чтобы найти по номеру, но если в середину вставить — придётся всех сдвигать, овердохуища работы. LinkedList — это цепочка, где каждый знает только соседа, вставить в середину легко, а найти по номеру — иди по цепочке и хуярь себя в сраку. ConcurrentHashMap — это умный шкаф, в который можно лазить из нескольких потоков, и он не развалится.
• Исключения: Throwable — дедушка всех проблем. Error — это пиздец типа «память кончилась», нихуя не поправишь. Exception — это ошибка, которую можно попробовать поймать. Checked — это как мама заставляет тебя надеть шапку (компилятор не даст проигнорировать). Unchecked (RuntimeException) — это когда ты сам нахуй поскользнулся, никто не предупреждал.

2. JVM и производительность (где всё летит в пизду)

• Память: Heap — это общая куча, где живут все объекты. Stack — это личная полочка каждого потока для примитивов и ссылок. Metaspace — там классы хранятся, раньше это была PermGen, но её, блядь, убили.
• Сборка мусора: Мусорщики (GC) ходят и убирают объекты, на которые никто не ссылается. Алгоритмы разные: Serial — один старичок с метлой, Parallel — бригада гастарбайтеров, G1 — умный планировщик, который старается не останавливать мир надолго. Если GC работает как сука, приложение тормозит и все орут.
• Загрузка классов: Класслоадеры — это цепочка ответственных. Сначала спрашивают у родителя: «У тебя есть класс java.lang.String?». Если нет — ищут сами. ClassNotFoundException — это «я вообще не нашёл файл с этим классом». NoClassDefFoundError — это «я нашёл файл, но когда попытался его прочитать, там какая-то хуйня, и теперь класса нет».

3. Паттерны проектирования (чтобы не изобретать велосипед с квадратными колёсами)

• Singleton: Чтобы класс был в единственном экземпляре, как я, блядь. Но если делать его на многопоточке — нужно голову поломать, чтобы два потока не создали два экземпляра. Double-Checked Locking — это как заглянуть в комнату (if (instance == null)), потом, если пусто, взять ключ (synchronized), зайти, и ещё раз проверить, не пришёл ли уже кто-то.
• Factory: Ты не говоришь «создай мне конкретно ToyotaCamry». Ты говоришь «эй, завод, дай мне седан», а завод уже сам решает, какую хуйню тебе склепать.
• Observer: Это как подписаться на паблик. Источник события (Subject) орет: «Новость!», а все подписчики (Observers) получают пуш и делают что хотят.

4. Фреймворки (Spring — наш всему голова)

• Spring Core: Dependency Injection — это когда тебе не нужно самому искать зависимости (new SomeService()). Ты просто заявляешь: «Хочу @Autowired SomeService», а Spring, как хитрая жопа, сам подсовывает тебе готовый бин. AOP — это магия, которая позволяет навесить общую логику (логирование, транзакции) на кучу методов, не копипастя её в каждом.
• Spring Data / JPA: Ты описываешь сущность как класс, а фреймворк сам генерирует SQL. @Transactional — это волшебная обёртка, которая говорит: «Всё в этом методе — одна транзакция. Либо выполнится всё, либо откатится всё, хуй с горы». Проблема N+1 — это когда ты для каждой записи в списке делаешь отдельный запрос в БД, и сервер ложится, блядь.
• Hibernate: Кэш первого уровня — в рамках одной сессии. Второго — общий на всё приложение. Lazy loading — это «не грузи связанные данные, пока явно не попросишь», иначе можно выгрузить полбазы в память по одному чиху.

5. Алгоритмы (чтобы не прослыть ебланом)

• Сортировки: QuickSort — быстрая, но может деградировать до O(n²), если опорный элемент выбирать как попало. MergeSort — стабильно O(n log n), но жрёт память. Нужно понимать, когда что применять, а не просто Arrays.sort() тыкать.
• Поиск в графах: BFS (поиск в ширину) — идёт слоями, как волна, находит кратчайший путь. Использует очередь. DFS (поиск в глубину) — полез в одну дырку, пока не упрётся, потом назад. Использует стек или рекурсию. Рекурсия, конечно, может кончиться StackOverflowError, если граф глубокий, но это уже твои проблемы.

Вот тебе тот самый Singleton, о котором все спрашивают, с двойной проверкой, блядь:

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) { // Первая проверка (без блокировки)
            synchronized (Singleton.class) {
                if (instance == null) { // Вторая проверка (под блокировкой)
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

Зачем volatile? Чтобы JVM не переупорядочила операции при создании объекта, и другой поток не получил наполовину созданный инстанс. Это, сука, важно.

Что делать? Иди на LeetCode, хуярь задачи уровня Medium. Проектируй системы, которые не развалятся от десяти пользователей. Учись смотреть EXPLAIN для SQL-запросов и понимать, почему он использует не тот индекс, пидарас. Удачи, епта.