Задача: посчитать цену со скидкой для VIP, GOLD и новых клиентов. Код работает, но в нём магические 0.8, 0.9 и 500 и лесенка if 😬
Чиним за 3 шага:
1️⃣ константы с понятными именами
2️⃣ Map «тип → функция» вместо if
3️⃣ BigDecimal вместо double
Было 3 магических числа и 3 if — стало ни одного.
⚠️ Нюанс: BigDecimal создавай из строки. Почему new BigDecimal(0.1) — плохая идея, видно прямо в ролике.
Сохрани — пригодится на код-ревью 📌
Джун идёт с конца и делает r += s.charAt(i). Работает, но каждое += копирует всю строку: на 100 000 символов это около 5 млрд копий.
Сеньор пишет new StringBuilder(s).reverse() — один проход. Но есть нюанс 👀
Почему reverse() может испортить текст с акцентами и эмодзи — в ролике.
А ты как бы решил? Пиши в комментариях 👇
Обычный HashMap ломается, если в него пишут несколько потоков. Разбираем, как с этим справляется ConcurrentHashMap (Java 8+).
1️⃣ Внутри — тот же массив корзин
Можно было бы закрыть всю мапу одним замком, как делает Collections.synchronizedMap, но тогда потоки стояли бы в очереди друг за другом.
2️⃣ Пустая корзина → CAS
Если корзина пуста, узел кладётся операцией CAS (compare-and-set): «запиши, только если там всё ещё пусто». Без блокировок. Не успел — поток перечитывает и пробует снова.
3️⃣ Занятая корзина → замок только на неё
Если в корзине уже есть узлы, поток берёт synchronized на её первый узел. Остальные корзины свободны, и другие потоки пишут туда параллельно.
4️⃣ Чтение без блокировок
get вообще не берёт замков: ссылки читаются как volatile, поэтому поток видит свежие данные.
⚠️ Где ломается
— null в ключах и значениях запрещён → NullPointerException
— if (!map.containsKey(k)) map.put(k, v) — не атомарно, используй putIfAbsent или computeIfAbsent
— size() — лишь оценка в моменте: другие потоки меняют мапу параллельно
💡 Полезно знать
— счётчик по ключу в одну строку: map.merge(key, 1, Integer::sum)
— итераторы не бросают ConcurrentModificationException
— до Java 8 вместо замков на корзины были сегменты
Два похожих метода — и два разных ответа:
int a() {
try { return 1; }
finally { return 2; }
} // вернёт 2
int b() {
int x = 1;
try { return x; }
finally { x = 2; }
} // вернёт 1
👉 Коротко: finally выполняется всегда, даже после return. Если в finally свой return — он побеждает. Если finally просто меняет переменную — уже поздно, результат запомнен.
🔍 Метод a():
1️⃣ В try встречается return 1 — Java готовится вернуть 1.
2️⃣ Перед выходом обязательно выполняется finally.
3️⃣ Там return 2 — он перезаписывает результат. Метод вернёт 2.
🔍 Метод b():
1️⃣ return x вычисляет значение (1) и откладывает его в сторону.
2️⃣ finally меняет x на 2.
3️⃣ Но вернётся то, что отложили — 1.
⚠️ Где ещё всплывает:
• return в finally «съедает» исключение: ошибка из try просто исчезнет, и ты о ней не узнаешь.
• Если вернуть объект (например, список) и изменить его в finally — изменения будут видны. Откладывается ссылка на объект, а не его копия.
• finally не выполнится, если вызвать System.exit() или если упадёт сама JVM.
✅ Как правильно:
В finally — только закрытие ресурсов. А ещё лучше — try-with-resources, он закроет всё сам.
Задача: показать статус заказа по-русски. Код работает, но это цепочка из 4 if-else по строкам 😬
Чиним за 3 шага:
1️⃣ switch-выражение вместо if-else
2️⃣ enum вместо строк
3️⃣ подпись — полем внутри enum
Было 13 строк и 4 if — стало 8 и ни одного.
⚠️ Нюанс: Status.valueOf бросает исключение на любой строке, которой нет в enum, даже с лишним пробелом.
Сохрани — пригодится на код-ревью 📌
Задача: посчитать, сколько раз встречается каждое слово.
Джун: containsKey, потом get, потом put. Работает, но это до трёх поисков в мапе на каждое слово.
Сеньор: одна строка с merge — один вызов вместо трёх. Но есть нюанс 👀
Что сломается, если слова считают несколько потоков, и как это починить — в ролике.
А ты как бы решил? Пиши в комментариях 👇
Подписывайся — скоро новая битва Junior vs Senior ⚔️
Junior vs Senior #01 ⚔️
Задача: есть ли в списке дубликаты?
Джун пишет два вложенных цикла. Работает, но на 100 000 элементов это около 5 млрд сравнений.
Сеньор обходится одной строкой с HashSet — быстро и красиво. Но есть нюанс 👀
Что не так с решением сеньора и как сделать ещё лучше — в ролике.
А ты как бы решил? Пиши в комментариях 👇
Задача: собрать email активных пользователей. Код работает, но превратился в лесенку из if 🪜
Чиним за 3 шага:
1️⃣ ранний выход вместо внешнего if
2️⃣ одно условие вместо трёх вложенных
3️⃣ stream вместо цикла
Было 15 строк и 4 if — стало 9 и один.
⚠️ Нюанс: toList() возвращает неизменяемый список. Если результат потом дополняют — бери collect(Collectors.toList()).
Блиц по строкам в Java ⏱
3 вопроса — от лёгкого к сложному. Отвечай, пока тикает таймер. Не успеваешь — ставь на паузу 😉
1️⃣ toUpperCase() без присваивания
2️⃣ 1 + 2 + "3" + 4 + 5
3️⃣ null + "a"
Третий — с подвохом 👀
Пиши в комментариях свой счёт из 3 👇 Ответы с разбором — в закрепе.
Подписывайся — скоро блиц на новую тему ⏱
ArrayList изнутри — за минуту 📦
Почему ArrayList мгновенно отдаёт элемент по индексу, но тормозит на вставке в середину? Всё решает то, что лежит внутри.
1️⃣ Внутри — обычный массив
Его длина — это capacity, а size — сколько ячеек реально занято. get(i) просто читает одну ячейку, без перебора: O(1).
2️⃣ Рост в 1,5 раза
new ArrayList() стартует с пустого массива, а при первом add он становится на 10 ячеек. Когда места нет, создаётся новый массив размером old + old / 2 (10 → 15 → 22 → 33), и все элементы копируются туда. Старый массив уходит сборщику мусора.
3️⃣ Вставка в середину
add(2, "Z") сначала сдвигает весь хвост на одну ячейку вправо и только потом кладёт элемент. remove(i) так же двигает хвост влево. Чем длиннее список, тем дороже: O(n).
📊 Шпаргалка: get(i) — O(1), add(e) в конец — O(1) в среднем, add(i, e) и remove(i) — O(n).
⚠️ Где ломается
— list.remove(1) на List Integer удаляет элемент по индексу 1, а не число 1
— удаление в for-each → ConcurrentModificationException, используй removeIf
— несколько потоков → ArrayList не потокобезопасен
💡 Полезно знать
— знаешь размер заранее → new ArrayList(n), лишних копирований не будет
— trimToSize() обрезает массив до size, если список больше не растёт
Родитель A, наследник B. Что напечатает new B()?
class A {
static { p(1); }
{ p(2); }
A() { p(3); }
}
class B extends A {
static { p(4); }
{ p(5); }
B() { p(6); }
}
new B(); // 1 4 2 3 5 6
new B(); // 2 3 5 6
👉 Коротко: сначала один раз готовятся классы (static), от родителя к наследнику. Потом собирается объект — тоже от родителя к наследнику.
🔍 Что происходит по шагам:
1️⃣ Java впервые встречает класс B и готовит его. Но сначала — родителя A: static A → 1, затем static B → 4.
2️⃣ Создаётся объект. Конструктор B первым делом вызывает конструктор A.
3️⃣ Собирается часть A: блок { } → 2, конструктор → 3.
4️⃣ Собирается часть B: блок { } → 5, конструктор → 6.
5️⃣ Второй new B(): классы уже готовы, static не повторяется → 2 3 5 6.
🏠 Аналогия: дом строят снизу вверх. Фундамент (static) заливают один раз. Каждую новую квартиру собирают с первого этажа (A) и выше (B).
⚠️ Где ещё всплывает:
• Блоки { } и значения полей выполняются в том порядке, в котором написаны в классе.
• Опасно вызывать из конструктора родителя метод, который переопределил наследник: поля наследника ещё не заполнены и равны 0 или null.
📌 Запомни: static — один раз, от родителя к наследнику. Объект — каждый раз, тоже от родителя к наследнику.
Как устроен HashMap — за минуту 🗺️
HashMap спрашивают почти на каждом собеседовании. Разбираем по шагам, что происходит внутри, когда ты пишешь map.put("лис", 7).
1️⃣ Ключ → номер корзины
HashMap берёт "лис".hashCode() = 1075332, перемешивает старшие биты с младшими (h ^ h 16 = 1075348) и накладывает маску по размеру массива: 1075348 & 15 = 4. Значит, корзина номер 4.
2️⃣ Корзины — это обычный массив
По умолчанию в нём 16 ячеек, и создаётся он при первом put. Ничего не перебираем — сразу идём в нужную ячейку.
3️⃣ В корзине лежит список узлов
Каждый узел хранит хэш, ключ, значение и ссылку на следующий. Если в корзине уже кто-то есть, это коллизия, и новый узел встаёт в конец списка. get проходит тот же путь и сравнивает сначала хэш, потом equals.
4️⃣ Рост
Когда элементов больше, чем 75% от числа корзин, массив удваивается. Хэш заново не считается: каждый узел остаётся на своём месте или сдвигается ровно на старую длину массива (наш «лис» переехал из 4 в 20).
🌳 Нюанс: если в одной корзине больше 8 узлов, список превращается в красно-чёрное дерево, но только когда корзин уже 64 или больше. Иначе HashMap просто расширяется.
⚠️ Где чаще всего ломается
— переопределил equals без hashCode → равные ключи попадут в разные корзины
— поменял поле ключа после put → ключ «потерялся» в старой корзине
— пишешь из нескольких потоков → нужен ConcurrentHashMap
💡 Полезно знать
— ключ null разрешён, он всегда лежит в корзине 0
— знаешь размер заранее → HashMap.newHashMap(n) (Java 19+), лишних расширений не будет
Ждёшь ab, а получаешь 195 🤯
var r1 = 'a' + 'b'; // 195
var r2 = "" + 'a' + 'b'; // "ab"
var r3 = 'a' + 'b' + ""; // "195"
Почему так:
🔹 char в Java — это не строка, а 16-битное число без знака: код символа в UTF-16. 'a' = 97, 'b' = 98.
🔹 При сложении двух char оба расширяются до int (binary numeric promotion), поэтому 'a' + 'b' = 97 + 98 = 195, и это int.
🔹 Оператор + вычисляется слева направо. Как только слева оказывается String, дальше идёт конкатенация, поэтому "" + 'a' + 'b' даёт "ab".
🔹 В 'a' + 'b' + "" сначала складываются числа (195), и только потом результат превращается в строку "195".
Связанные ловушки:
⚠️ char c = 'a' + 1; компилируется и даёт 'b', потому что это константа и она помещается в char. А char d = c + 1; уже не компилируется: результат int, а сужение нужно делать явно.
⚠️ sb.append('a' + 'b') у StringBuilder добавит "195", а не "ab".
⚠️ System.out.println('a' + 'b') вызовет перегрузку println(int).
Вопрос, на котором путаются даже опытные разработчики 🤯
int i = 0;
i = i++;
System.out.println(i); // 0
Инкремент выполнился, но результат всё равно 0. Разбираемся, что делает JVM.
Что происходит в байткоде:
Строка i = i++ компилируется в три инструкции:
1️⃣ iload_1 кладёт текущее значение i (ноль) на стек операндов.
2️⃣ iinc 1, 1 увеличивает саму переменную, теперь i = 1.
3️⃣ istore_1 берёт со стека старый ноль и записывает его обратно в i.
Итог: единица затёрта, i снова 0.
Главное правило:
🔹 i++ (постфиксный) сначала возвращает старое значение, потом увеличивает.
🔹 ++i (префиксный) сначала увеличивает, потом возвращает новое.
Это прямо прописано в спецификации языка (JLS 15.14.2), так что поведение одинаковое на любой JVM. В C такая строка вообще неопределённое поведение, а Java чётко задаёт порядок вычислений.
В Java есть две независимые иерархии потоков:
• Байтовые (InputStream/OutputStream) — работают с byte. Подходят для бинарных данных: изображения, архивы, PDF, сетевые протоколы. Они ничего не знают о кодировках — просто читают и пишут байты.
• Символьные (Reader/Writer) — работают с char (UTF-16 внутри Java). Подходят для текста: файлы, JSON, CSV, HTML. Они обязаны знать кодировку, чтобы правильно преобразовать байты в символы.
Связь между ними — мосты:
• InputStreamReader — читает байты, декодирует в символы.
• OutputStreamWriter — кодирует символы в байты.
Как каждая коллекция вставляет элемент в Java:
🟦 ArrayList: add(i, x) сдвигает весь хвост массива, это O(n). Зато get(i) за O(1) и дружба с кэшем процессора.
🔗 LinkedList: сама вставка O(1), но сначала надо дойти до нужного узла, а это O(n). Плюс по объекту-узлу на каждый элемент.
⭕ ArrayDeque: кольцевой буфер, head и tail просто бегут по кругу. Добавление и удаление с обоих концов за O(1), без сдвигов.
Итог: по умолчанию ArrayList, для очереди и стека ArrayDeque.
IDENTITY — самая популярная стратегия генерации ID. Но с batch insert у неё особые отношения. В видео — короткий пример и четыре варианта ответа. Выбери свой, а завтра я покажу правильный разбор.
📌 Сохрани пост, чтобы не терять производительность на массовых вставках — эта ловушка всплывает при импорте данных.
💬 Напиши в комментариях, какой вариант выбрал — посмотрим, кто знает стратегии генерации ID.
Джун пишет авто-конфигурацию и объявляет дефолтный бин PaymentClient без условий. Пока пользователь не добавил свой бин — всё работает. Как только добавил — в контексте два бина одного типа, и приложение падает с NoUniqueBeanDefinitionException или BeanDefinitionOverrideException. Сеньор добавляет @ConditionalOnMissingBean, и дефолт аккуратно отключается.
💡 Что такое @ConditionalOnMissingBean?
Это условная аннотация Spring Boot. Она говорит: «Создай этот бин, только если в контексте нет бина указанного типа (или имени)». Чаще всего используется в авто-конфигурациях, чтобы дать разумный дефолт, который пользователь может заменить своим бином.
По умолчанию тип выводится из возвращаемого типа метода. Можно указать явно: @ConditionalOnMissingBean(PaymentClient.class). Проверка идёт по типу, а не только по имени бина. Поэтому если пользователь назвал свой бин customPaymentClient, но тип тот же PaymentClient, дефолт всё равно отключится.
⚠️ Нюанс: Условие вычисляется в момент обработки конфигурации, поэтому порядок имеет значение. Если бин пользователя объявлен позже, условие может не увидеть его. В авто-конфигурациях Spring Boot это решается через @AutoConfigureAfter/@AutoConfigureBefore. Также не ставь @ConditionalOnMissingBean на бины, которые нужны всегда: если кто-то случайно объявит бин того же типа, дефолт исчезнет, и приложение может упасть с NoSuchBeanDefinitionException. И помни: в Spring Boot 2.1+ переопределение бинов по умолчанию запрещено (spring.main.allow-bean-definition-overriding=false), поэтому «тихое» переопределение больше не сработает.
