👩‍💻 Основы многопоточности в Java

Приглашаем на открытый урок.

🗓 23 июля в 20:00 МСК
🆓 Бесплатно. Урок в рамках старта курса «Java-разработчик».

На уроке разберем:
✔️ Что такое поток выполнения и почему даже обычная Java-программа работает в главном потоке main.
✔️ Как создавать и запускать потоки через Thread и Runnable.
✔️ Зачем нужен join и как дождаться завершения запущенных потоков.
✔️ Почему многопоточность может ускорить программу, а может добавить лишние накладные расходы.
✔️ Какие типовые проблемы возникают в многопоточном коде: гонки, starvation и deadlock.

🔗 Ссылка на регистрацию: https://vk.cc/cZAF9K

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576

☕️ Лямбды и Функциональные интерфейсы: Как это работает под капотом?

Мы все любим лямбды в Java за краткость. Но задумывались ли вы, как строго типизированная Java понимает запись x -> x * 2, не зная типа переменной x?

Все дело в Функциональных интерфейсах. Давайте разберем механику, которая превращает "бойлерплейт" в элегантный код.

🧩 Что такое SAM?
В основе лежит концепция SAM (Single Abstract Method). Функциональный интерфейс - это интерфейс, у которого есть ровно один абстрактный метод.

Лямбда-выражение - это не самостоятельный объект. Это ленивая реализация этого самого единственного метода "на лету".

🔥 До vs После
Взгляните, как функциональный интерфейс Predicate<T> убивает лишний шум:

// ❌ До Java 8 (Анонимный класс)
// Куча лишнего кода ради одной проверки
Predicate<String> isLong = new Predicate<String>() {
    @Override
    public boolean test(String s) {
        return s.length() > 5;
    }
};

// ✅ С Лямбдой
// Компилятор видит Predicate -> ищет метод test -> подставляет логику
Predicate<String> isLong = s -> s.length() > 5;

⚙️ Магия invokedynamic
Многие думают, что лямбда - это просто "сахар" для анонимных классов. Это не так!

💜 Анонимный класс создает реальный .class файл на диске при компиляции.
💜 Лямбда использует инструкцию байт-кода invokedynamic. Она связывает метод динамически только когда это нужно.
👉 Итог: Меньше мусора в памяти и быстрее загрузка приложения.

📚 Шпаргалка: "Великолепная четверка"
В java.util.function есть интерфейсы на все случаи жизни. Запомните базу:

1. Predicate<T> ➜ boolean
💜 Суть: Проверка условия (фильтры).
💜 Пример: stream().filter(x -> x > 0)


2. Consumer<T> ➜ void
💜 Суть: Потребитель. Что-то делает с объектом, ничего не возвращая.
💜 Пример: list.forEach(System.out::println)


3. Function<T, R> ➜ R
💜 Суть: Преобразователь. Берет T, возвращает R.
💜 Пример: stream().map(User::getName)


4. Supplier<T> ➜ T
💜 Суть: Поставщик. Ничего не принимает, отдает объект.
💜 Пример: Optional.orElseGet(() -> new User())


💡Всегда ставьте аннотацию @FunctionalInterface над своими интерфейсами. Это защитит от случайного добавления второго абстрактного метода, который сломает все лямбды в проекте.

📲 Мы в MAX

👉 @java_geek

⚔️ Java Battle: List.of() vs Arrays.asList() - в чем разница?

На код-ревью часто можно увидеть, как эти два метода используют взаимозаменяемо. На первый взгляд, результат один - список элементов. Но под капотом это два совершенно разных зверя.

Давайте разберем, почему замена одного на другой может сломать ваш код.

1. Иллюзия неизменяемости (The Mutability Trap)

Это самое важное различие.

🔴List.of() (Java 9+): Создает по-настоящему неизменяемый список. Вы не можете ни добавить, ни удалить, ни изменить элемент.
🔴Arrays.asList() (Java 1.2+): Создает список фиксированного размера, который "обернут" вокруг массива. Вы не можете менять размер (add/remove), но можете заменять элементы!

var legacyList = Arrays.asList("A", "B");
var modernList = List.of("A", "B");

legacyList.set(0, "C"); // ✅ РАБОТАЕТ! Список теперь ["C", "B"]
modernList.set(0, "C"); // ❌ Ошибка: UnsupportedOperationException

legacyList.add("D");    // ❌ Ошибка (размер фиксирован)
modernList.add("D");    // ❌ Ошибка (полная иммутабельность)

2. Отношение к null

🔴Arrays.asList: Разрешает null элементы.
🔴List.of: Враждебен к null. Если попытаетесь передать null, мгновенно получите NullPointerException. Это сделано специально, чтобы избежать ошибок в логике.

3. Связь с исходным массивом (Reference vs Copy)

Если вы создаете список из существующего массива:

String[] arr = {"One", "Two"};
var list1 = Arrays.asList(arr);
var list2 = List.of(arr);

arr[0] = "Zero"; // Меняем исходный массив

System.out.println(list1); // ["Zero", "Two"] <- Изменился вслед за массивом!
System.out.println(list2); // ["One", "Two"]  <- Остался прежним

Arrays.asList работает как "окно" (view) в массив. List.of создает защитную копию данных.

🏁 Итог

🔴Используйте List.of() в 99% случаев. Это безопаснее, быстрее и потребляет меньше памяти.
🔴Используйте Arrays.asList(), только если вам нужны null-ы или вы намеренно хотите, чтобы изменения в исходном массиве отражались в списке (редкий кейс).

#Java #CodeTips #InterviewQuestions #JavaCore

📲 Мы в MAX

👉 @java_geek

🕵️ Java var: Удобный сахар или скрытая угроза?

С выходом Java 10 ключевое слово var позволило нам писать меньше кода. var - это Local Variable Type Inference. Это значит, что Java осталась строго типизированным языком, просто теперь компилятор сам догадывается о типе переменной, глядя на то, что находится справа от знака равно (=).

Но иногда его догадки могут вас удивить. Вот 3 примера, где var работает неочевидно.

1. Ловушка "Diamond Operator" (<>)

Самая частая ошибка новичков.

// Без var (Классика)
List<String> list = new ArrayList<>(); 
// Компилятор видит слева List<String> и понимает, что справа тоже String.

// С var (Ошибка)
var list = new ArrayList<>(); 

В чем проблема?
У компилятора нет информации о типе. Он видит пустые скобки <> и решает, что это ArrayList<Object>.
В итоге вы теряете типизацию:

list.add("Hello");
list.add(123); // ✅ Это сработает, хотя вы, вероятно, хотели только строки!

✅ Как исправить:
Если используете var с конструктором, всегда указывайте тип справа:

var list = new ArrayList<String>();

2. Магия "Пересечения типов" (Intersection Types)

А вот это уже высший пилотаж, который часто встречается при использовании List.of() или Map.of().

Что будет, если сложить в список данные разных типов?

var magicList = List.of(10, 20.5, "30"); 
// Какой тут тип списка? List<Object>?

На самом деле компилятор выведет наиболее специфичный общий тип.
Тип переменной magicList будет выглядеть примерно так:
List<? extends Serializable & Comparable<? extends Serializable & Comparable<?>>>

Java находит общие интерфейсы для Integer, Double и String (все они реализуют Serializable и Comparable) и создает этот ужасный тип-франкенштейн. Это работает, но может свести с ума вашу IDE или методы, принимающие конкретные типы.

3. Анонимные классы на стероидах

var позволяет делать трюк, невозможный ранее: сохранять тип анонимного класса.

var user = new Object() {
    String name = "Alex";
    int age = 25;
};

// Это работает!
System.out.println(user.name); 
System.out.println(user.age);

Если бы мы написали Object user = ..., поля name и age были бы недоступны. А var "видит" реальную структуру анонимного объекта. Это иногда полезно для локальных промежуточных вычислений, заменяя DTO или кортежи.

🧠 Золотое правило использования

var хорош тогда, когда тип очевиден из правой части:

🔴👍 var users = Map.of("id", 1); (Понятно, что это Map)

🔴👍 var stream = list.stream(); (Понятно, что Stream)

🔴👎 var result = service.process(); (Что вернулось? boolean? User? null?)

Читаемость кода важнее краткости!

📲 Мы в MAX

👉 @java_geek