🗺 map() vs flatMap(): Битва трансформеров

Оба метода находятся в конвейере (Intermediate operations) и нужны для преобразования данных. Но работают они с разной геометрией.

1️⃣ map() - Один к одному (1:1)

Самый простой случай. Вы берете элемент, делаете с ним что-то и возвращаете один измененный элемент. Структура потока не меняется.

💙Логика:
💙Пример: Есть список сотрудников (Employee), нужно получить список их имен (String).
💙Аналогия: У вас есть коробка с яблоками. Вы берете каждое яблоко, чистите его и кладете обратно. В итоге у вас столько же объектов, просто они изменились.

stream.map(employee -> employee.getName()) // Был Employee, стал String

2️⃣ flatMap() - Один ко многим (1:N) + Сплющивание

Этот метод нужен, когда элементы стрима - это контейнеры (списки, массивы), и вам нужно достать содержимое наружу, "сплющив" всё в один поток.

💙Логика:
💙Пример: Есть список отделов (Department), в каждом отделе - список сотрудников (List<Employee>). Вы хотите получить один общий список всех сотрудников компании.
💙Аналогия: У вас есть коробка, внутри которой лежат маленькие коробочки с конфетами.
💙Если сделать map, у вас будет поток коробочек.
💙Если сделать flatMap, вы высыпаете конфеты из всех коробочек в одну большую кучу.



💻 Код: Почувствуйте разницу

Допустим, у нас есть "Списков списков":
List<List<String>> nestedList = List.of(List.of("A", "B"), List.of("C", "D"));

❌ Попытка с map:

// Мы получим Stream из Списков: Stream<List<String>>
nestedList.stream()
    .map(list -> list.stream()) 
    .toList(); 
// Результат: [[A, B], [C, D]] — Матрёшка осталась!

✅ Решение с flatMap:

// Мы получим единый Stream строк: Stream<String>
nestedList.stream()
    .flatMap(list -> list.stream()) // Превращаем каждый список в стрим и сливаем
    .toList(); 
// Результат: [A, B, C, D] — То, что нужно!

⚡ Когда что использовать?

1. map: Используем в 90% случаев. Когда нужно просто превратить А в Б (Число в Строку, Объект в Поле объекта).
2. flatMap: Используем, когда нужно убрать вложенность.
💙List<List<T>> List<T>
💙Работа с файлами (список строк из списка файлов).
💙Работа с Order List<LineItem>.


🔥 Итог

💙 map преобразует элементы.
💙flatMap преобразует и разворачивает структуру.

#Java #StreamAPI #MapVsFlatMap #InterviewQuestions

📲 Мы в MAX

👉@BookJava

🚀 В чем разница между HashMap и Hashtable в Java?

Если вы работаете с Java, то наверняка сталкивались с HashMap и Hashtable. Оба используются для хранения пар "ключ-значение", но между ними есть важные различия. Давайте разберемся!

1. Синхронизация (Потокобезопасность)
- Hashtable:
- Синхронизирован (потокобезопасен). Все его методы синхронизированы, то есть только один поток может работать с ним одновременно.
- Это делает Hashtable безопасным для многопоточных сред, но может снижать производительность в однопоточных сценариях.
- HashMap:
- Не синхронизирован (не потокобезопасен). Несколько потоков могут обращаться к нему одновременно, что может привести к проблемам в многопоточных средах.
- Для потокобезопасности можно использовать Collections.synchronizedMap(new HashMap<>()) или ConcurrentHashMap.


2. Null-ключи и Null-значения
- Hashtable:
- Не позволяет использовать null в качестве ключа или значения. Попытка добавить null вызовет NullPointerException.
- HashMap:
- Разрешает один null - ключ и множество null -значений.


3. Производительность
- Hashtable:
- Медленнее из-за накладных расходов на синхронизацию.
- HashMap:
- Быстрее в однопоточных средах, так как не синхронизирован.


4. Наследие
- Hashtable:
- Считается устаревшим классом (появился в Java 1.0). Не является частью Java Collections Framework.
- HashMap:
- Часть Java Collections Framework (появился в Java 1.2). Более современный и широко используемый.


5. Итерация
- Hashtable:
- Использует Enumeration для перебора ключей и значений.
- HashMap:
- Использует Iterator, который более гибкий и позволяет удалять элементы во время перебора.


6. Наследование
- Hashtable:
- Наследуется от класса Dictionary (абстрактный класс, который сейчас считается устаревшим).
- HashMap:
- Наследуется от AbstractMap, который является частью Java Collections Framework.


7. Рекомендации по использованию
- Используйте HashMap, если:
- Работаете в однопоточной среде.
- Нужна высокая производительность.
- Требуется поддержка null-ключей или значений.
- Используйте Hashtable, если:
- Нужна потокобезопасность в многопоточной среде.
- Однако в современной Java ConcurrentHashMap предпочтительнее, так как он обеспечивает лучшую производительность и масштабируемость.


Пример кода

Hashtable:

Hashtable<String, Integer> hashtable = new Hashtable<>();
hashtable.put("one", 1);
hashtable.put("two", 2);
// hashtable.put(null, 3); // Выбросит NullPointerException
System.out.println(hashtable);

HashMap:

HashMap<String, Integer> hashMap = new HashMap<>();
hashMap.put("one", 1);
hashMap.put("two", 2);
hashMap.put(null, 3); // Разрешено
System.out.println(hashMap);

Итоговая таблица

| Особенность | Hashtable | HashMap |
|-------------------------|---------------------------------|-------------------------------|
| Синхронизация | Синхронизирован | Не синхронизирован |
| Null-ключи/значения | Запрещены | Разрешены |
| Производительность | Медленнее | Быстрее |
| Наследие | Устаревший (Java 1.0) | Современный (Java 1.2) |
| Итерация | Enumeration | Iterator |
| Наследование | Наследует Dictionary | Наследует AbstractMap |

💡Совет: В современной разработке на Java HashMap используется чаще. Если нужна потокобезопасность, лучше выбрать ConcurrentHashMap, а не Hashtable.

📲 Мы в MAX

👉@BookJava

🛒 Collectors: Собираем урожай Stream API

Мы отфильтровали, преобразовали и отсортировали данные. Теперь их нужно сложить в коробочку, чтобы использовать дальше. Для этого существует терминальная операция .collect().

Внутрь нее мы передаем специальный объект - Collector. Чтобы не писать его вручную, в Java есть утилитный класс Collectors с готовыми решениями на все случаи жизни.

📦 Базовый набор (Must Have)

1. В список или множество
💙Collectors.toList() - собирает все в ArrayList (но тип не гарантирован).
💙Collectors.toSet() - собирает в HashSet (убирает дубликаты).
💙Java 16+ Update: Теперь можно просто писать .toList() прямо у стрима, без collect(...). Это создает неизменяемый список.


2. В строку (joining)
💙Больше не нужно мучиться с StringBuilder в циклах.
💙Collectors.joining(", ") - склеит строки через запятую.



🔑 Продвинутый уровень: Карты и Группировки

Самая мощная магия происходит здесь.

3. В Map (toMap)
Превращает список объектов в Map (ключ-значение).
💙Синтаксис: toMap(Function keyMapper, Function valueMapper)
💙Важно: Если ключи совпадут, вылетит IllegalStateException.
💙Лечение: Третий аргумент - "мердж-функция" (что делать при конфликте).


4. Группировка (groupingBy)
Аналог GROUP BY из SQL. Это киллер-фича Stream API.
💙Разделяет элементы на группы по какому-то признаку и кладет их в Map<Критерий, Список>.


💻 Примеры в коде

Представьте, у нас есть класс User(String name, String role).

List<User> users = List.of(
    new User("Alex", "ADMIN"),
    new User("Bob", "USER"),
    new User("Charlie", "USER")
);

// 1. Склеиваем имена в одну строку
String names = users.stream()
    .map(User::getName)
    .collect(Collectors.joining(", "));
// Результат: "Alex, Bob, Charlie"

// 2. Превращаем в Map: Имя -> Роль
Map<String, String> userMap = users.stream()
    .collect(Collectors.toMap(
        User::getName, // Ключ
        User::getRole  // Значение
    ));
// Результат: {Alex=ADMIN, Bob=USER, Charlie=USER}

// 3. Группируем по Роли (SQL GROUP BY)
Map<String, List<User>> byRole = users.stream()
    .collect(Collectors.groupingBy(User::getRole));
// Результат: 
// { 
//   "ADMIN": [User(Alex)], 
//   "USER":  [User(Bob), User(Charlie)] 
// }

⚡ Полезный лайфхак

В groupingBy можно передать второй коллектор! Например, чтобы не просто сгруппировать пользователей, а сразу посчитать их количество в каждой группе:

Map<String, Long> countByRole = users.stream()
    .collect(Collectors.groupingBy(
        User::getRole, 
        Collectors.counting() // Downstream collector
    ));
// Результат: {ADMIN=1, USER=2}

🔥 Итог

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

#Java #StreamAPI #Collectors #JavaTips

📲 Мы в MAX

👉@BookJava

🎯 Открытый урок «Linq на практике».

🗓 14 января в 20:00 МСК
🆓 Бесплатно. Урок в рамках старта курса «C# Developer».

На вебинаре будут рассмотрены:
✔️ синтаксис операторов linq;
✔️синтаксис компараторов, применяемых в linq-запросах;
✔️примеры linq-запросов для наиболее популярных коллекций.

Кому будет полезно:
- данная тема будет интересна всем, кто работает с массивами данных в рамках .NET. Вы сможете эффективно использовать простой синтаксис для наиболее частых операций применяемых в рамках работы с коллекциями.

Что вы получите:
- вы сможете писать свои linq-запросы, опираясь на синтаксис linq.Будете знать разницу при применении тех или иных методов в рамках написания linq-запросов.

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

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

🎁 Optional: Лекарство от NullPointerException

Тони Хоар назвал изобретение null своей "ошибкой на миллиард долларов". NullPointerException (NPE) - самый частый кошмар Java-разработчика.
В Java 8 появился Optional<T> - класс-обертка, который явно говорит: "Здесь значения может и не быть".

📦 Что внутри?

Представьте Optional как коробку.

🔴В ней может лежать объект (Non-empty).
🔴Или она может быть пустой (Empty).

Главное правило: Никогда не возвращайте null из метода, если можно вернуть Optional.empty().

🚫 Как делать НЕ надо

Самая частая ошибка новичка, использовать Optional как старый добрый if (x != null):

Optional<User> userOpt = findUser("Alex");

// ❌ ПЛОХО: Это тот же null-check, только сложнее
if (userOpt.isPresent()) {
    System.out.println(userOpt.get().getName());
}

Метод .get() - это зло. Если коробка пуста, он бросит NoSuchElementException, и вы просто поменяли шило (NPE) на мыло.

✅ Как делать НАДО (Functional Style)

Вся мощь Optional раскрывается, когда вы строите цепочки вызовов, как в стримах.

1. Если значение есть, сделай что-то (ifPresent)

findUser("Alex").ifPresent(user -> System.out.println(user.getName()));

2. Если значения нет, верни дефолт (orElse)

// Вернет юзера или создаст нового "Guest", если не нашел
User user = findUser("Alex").orElse(new User("Guest"));

3. Если значения нет — брось ошибку (orElseThrow)

User user = findUser("Alex")
    .orElseThrow(() -> new IllegalArgumentException("User not found"));

4. Преобразование внутри коробки (map)
Допустим, нам нужен не сам юзер, а его email. Если юзера нет, то и email нет.

String email = findUser("Alex")
    .map(User::getEmail)       // Достаем email (если юзер есть)
    .map(String::toUpperCase)  // В верхний регистр (если email был)
    .orElse("UNKNOWN");        // Если хоть на одном этапе было пусто

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

1. Только для возвращаемых значений! Не используйте Optional как тип поля в классе или аргумент метода. Это лишний оверхед и мусор в коде.
2. orElse() vs orElseGet():
🔴orElse(new Object()) - объект создается всегда, даже если он не нужен.
🔴orElseGet(() -> new Object()) - объект создается только если в коробке пусто (лениво). Используйте этот вариант для тяжелых объектов.


🔥 Итог

Optional спасает не тем, что убирает null, а тем, что заставляет вас явно обработать случай отсутствия значения.
Забудьте про .get(). Используйте .map(), .filter() и .orElse().

#Java #Optional #CleanCode #NoMoreNPE

📲 Мы в MAX

👉@BookJava

💿 Java Records: Убийцы бойлерплейта

Сколько раз вы создавали класс просто чтобы "перенести данные" из точки А в точку Б?
Вы пишете 3 поля, а потом IDE генерирует вам 50 строк кода: конструктор, геттеры, equals, hashCode, toString... 🤯

В Java 16+ этому положили конец. Встречайте Records.

📉 Было vs Стало

Допустим, нам нужен простой DTO для пользователя.

❌ Классический POJO (Java 1.0 - 15):

public class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }

    // + equals()
    // + hashCode()
    // + toString() ... еще 30 строк кода
}

✅ Record (Java 16+):

public record User(String name, int age) {}

Всё. Это одна строка. 🔥

⚙️ Что происходит под капотом?

Компилятор делает всю грязную работу за вас. Создавая record, вы автоматически получаете:

1. Приватные финальные поля (private final).
2. Конструктор со всеми аргументами.
3. Геттеры (без префикса get! Просто .name(), .age()).
4. equals() и hashCode() (идеально для ключей в Map или Set).
5. toString() (красивый вывод: User[name=Alex, age=25]).

🛠 Кастомизация (Compact Constructor)

"А что, если мне нужна валидация? Нельзя же создать юзера с отрицательным возрастом!"
Для этого есть Компактный конструктор. Вам даже не нужно перечислять аргументы:

public record User(String name, int age) {
    // Компактный конструктор
    public User {
        if (age < 0) {
            throw new IllegalArgumentException("Возраст не может быть меньше 0");
        }
        // Присваивание this.age = age происходит автоматически!
    }
}

⚠️ Ограничения (Важно знать)

Records, это не замена обычным классам во всем.

1. Они неизменяемы (Immutable). Сеттеров нет и не будет. Хотите поменять поле? Создавайте новый объект.
2. Нет наследования. Record не может наследовать (extends) другой класс (потому что он уже наследует java.lang.Record). Но имплементировать интерфейсы (implements) можно!

💡 Когда использовать?

🔴DTO (Data Transfer Objects): Ответы от API, запросы в БД.
🔴Ключи для Map: Благодаря гарантированному equals/hashCode.
🔴Внутри методов: Можно объявлять локальные рекорды прямо внутри метода, чтобы временно сгруппировать данные.

Records делают код чище и безопаснее. Они идеально сочетаются со Stream API, где данные постоянно передаются и преобразуются.
Если ваш класс это просто "мешок с данными", превращайте его в record.

#Java #Records #NewJava #CleanCode

📲 Мы в MAX

👉@BookJava

🔀 Switch Expressions: Прощай, break!

Помните это чувство, когда забыл написать break в switch-case, и код пошел выполняться дальше, создав неуловимый баг? 😫
В современных версиях Java (стандарт с Java 14) оператор switch прокачали. Теперь это не просто управляющая конструкция, а выражение, возвращающее результат.

💀 Было (Statement)

Громоздко, опасно (fall-through), переменная вынесена наружу.

DayOfWeek day = DayOfWeek.SATURDAY;
int numLetters;

switch (day) {
    case MONDAY:
    case FRIDAY:
    case SUNDAY:
        numLetters = 6;
        break; // Забыл break? Получи баг!
    case TUESDAY:
        numLetters = 7;
        break;
    default:
        throw new IllegalStateException("Wat: " + day);
}

✅ Стало (Expression)

Лаконично, безопасно, функционально.

int numLetters = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> 6;
    case TUESDAY                -> 7;
    default                     -> throw new IllegalStateException("Wat: " + day);
};

🚀 Главные фишки

1. Стрелочный синтаксис (->)
Если используется стрелка, переход к следующему кейсу (fall-through) отключен по умолчанию. Никаких break больше писать не надо!
2. Возврат значения
switch теперь работает как формула. Вы можете сразу присвоить результат переменной или вернуть его из метода (return switch(...)).
3. Несколько условий в одну строку
case MONDAY, FRIDAY, SUNDAY — просто перечисляем через запятую.

🛑 Сложная логика и yield

Что делать, если в одном case нужно не просто вернуть число, а выполнить несколько строк кода (например, залоггировать)?
Для этого появились фигурные скобки и ключевое слово yield.

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

String result = switch (day) {
    case SATURDAY, SUNDAY -> "Выходной";
    case MONDAY -> {
        System.out.println("Тяжелый день...");
        yield "Будни"; // yield возвращает значение из switch
    }
    default -> "Будни";
};

⚡ Exhaustiveness (Полнота)

Если вы делаете switch по Enum, компилятор проверит, все ли варианты вы обработали. Если добавите в Enum новый день, а в свич - нет, код просто не скомпилируется. Это отличная защита от забывчивости!

🔥 Итог

Новый switch это чистый кайф. Он делает код компактнее и убирает целый класс ошибок, связанных с пропущенными break.

🔴Используйте ->, когда нужно просто сопоставить значение.
🔴Используйте yield, если нужна логика внутри блока.

#Java #SwitchExpression #CleanCode #NewJava

📲 Мы в MAX

👉@BookJava