Java for Beginner

Вопросы с собеседования 👩‍💻

Что такое Checked Exception?

Anonymous Quiz

24%

Исключение, которое не нужно обрабатывать

70%

Исключение, которое компилятор требует обработать

Ошибка компиляции

Класс для работы с потоками

37 voters124 views13:44

Java for Beginner

Collectors в Java

groupingBy

Collectors.groupingBy – один из самых мощных коллекторов в Java Stream API, позволяющий группировать элементы потока по заданному критерию. Возвращает Map<K, List<T>>, где ключ (K) – это значение классификатора, а значение – список элементов, соответствующих этому ключу.

1. Базовая форма: groupingBy(classifier)
Группирует элементы по ключу, возвращаемому classifier (функцией классификации).

Сигнатура:

public static <T, K> Collector<T, ?, Map<K, List<T>>> groupingBy(  
    Function<? super T, ? extends K> classifier  
)

Пример:

List<String> names = List.of("Alice", "Bob", "Charlie", "Anna", "Alex");  

Map<Integer, List<String>> groupedByLength = names.stream()  
    .collect(Collectors.groupingBy(String::length));  

// Результат:
// {3=[Bob], 4=[Anna, Alex], 5=[Alice], 7=[Charlie]}

Как это работает внутри?

Классификатор (String::length) вычисляет ключ для каждого элемента.
Элементы с одинаковым ключом добавляются в List<T>.
По умолчанию используется HashMap, а значения хранятся в ArrayList.

2. groupingBy(classifier, downstream) – с дополнительным коллектором
Позволяет указать, как собирать элементы в группы (не только в List).

Сигнатура:

public static <T, K, A, D> Collector<T, ?, Map<K, D>> groupingBy(  
    Function<? super T, ? extends K> classifier,  
    Collector<? super T, A, D> downstream  
)

Примеры:

2.1. Группировка в Set вместо List

Map<Integer, Set<String>> groupedByLength = names.stream()  
    .collect(Collectors.groupingBy(  
        String::length,  
        Collectors.toSet()  
    ));

2.2. Подсчет количества элементов в каждой группе

Map<Integer, Long> countByLength = names.stream()  
    .collect(Collectors.groupingBy(  
        String::length,  
        Collectors.counting()  
    ));  
// Результат: {3=1, 4=2, 5=1, 7=1}

2.3. Объединение элементов в строку

Map<Integer, String> joinedNames = names.stream()  
    .collect(Collectors.groupingBy(  
        String::length,  
        Collectors.joining(", ")  
    ));  

// Результат: {3="Bob", 4="Anna, Alex", 5="Alice", 7="Charlie"}

3. groupingBy(classifier, mapFactory, downstream) – с выбором реализации Map
Позволяет указать конкретную реализацию Map (например, TreeMap или LinkedHashMap).

Сигнатура:

public static <T, K, D, A, M extends Map<K, D>> Collector<T, ?, M> groupingBy(  
    Function<? super T, ? extends K> classifier,  
    Supplier<M> mapFactory,  
    Collector<? super T, A, D> downstream  
)

Пример:

// Группировка с сохранением порядка (LinkedHashMap)  
LinkedHashMap<Integer, List<String>> orderedGroups = names.stream()  
    .collect(Collectors.groupingBy(  
        String::length,  
        LinkedHashMap::new,  
        Collectors.toList()  
    ));  

// Группировка с сортировкой по ключу (TreeMap)  
TreeMap<Integer, Set<String>> sortedGroups = names.stream()  
    .collect(Collectors.groupingBy(  
        String::length,  
        TreeMap::new,  
        Collectors.toSet()  
    ));

4. Многокритериальная группировка (вложенные groupingBy)
Можно группировать по нескольким уровням, создавая сложные структуры данных.

Пример:

record Person(String name, String city, int age) {}  

List<Person> people = List.of(  
    new Person("Alice", "NY", 25),  
    new Person("Bob", "LA", 30),  
    new Person("Charlie", "NY", 25),  
    new Person("David", "LA", 35)  
);  

// Группировка по городу, а затем по возрасту  
Map<String, Map<Integer, List<Person>>> multiLevelGroup = people.stream()  
    .collect(Collectors.groupingBy(  
        Person::city,  
        Collectors.groupingBy(Person::age)  
    ));  

// Результат:
// {
//   "NY": {25=[Alice, Charlie]},
//   "LA": {30=[Bob], 35=[David]}
// }

5. Производительность и особенности

Порядок элементов в группах зависит от исходного потока (если он ordered, как в List, порядок сохраняется).
Хэш-коллизии обрабатываются через HashMap.

Нюансы при параллельных стримах:
Если используется ConcurrentHashMap, группировка становится потокобезопасной.
В некоторых случаях groupingByConcurrent работает быстрее.

#Java #Training #Medium #Collectors #groupingBy

140 views14:59

Java for Beginner

Please open Telegram to view this post

VIEW IN TELEGRAM

138 views01:59

Java for Beginner

Please open Telegram to view this post

VIEW IN TELEGRAM

139 views03:59

Java for Beginner

Пишем тестовое задание от реального работодателя для новичков! Часть 3 (финал).

Встреча от 27.04.25

Запись встречи -
YOUTUBE
RUTUBE

На сегодняшней встрече мы с @Shikin_Anatoliy дописали тестовое задание от реального работодателя.

Что мы успели:
➡️ Реализовали создание матчей.
➡️ Продумали сложную логику генерации данных для турнирной таблицы
➡️ Конечно же допустили ошибки, и столкнулись с результатами неправильного проектирования.

Хотелось бы извиниться за склейки в финале видео, из-за неизвестного неадеквата 😞

Смотрите, комментируйте, задавайте вопросы! Обязательно подписывайтесь на ютуб и рутюб каналы!!!

Надеюсь видео будет полезным для новичков!

Please open Telegram to view this post

VIEW IN TELEGRAM

146 views04:34

Java for Beginner

Collectors в Java

Collectors.summingInt

Collectors.summingInt — это специализированный коллектор, предназначенный для суммирования целочисленных значений, извлекаемых из элементов потока. Он особенно полезен, когда нужно вычислить общую сумму числовых характеристик объектов.

1. Базовая форма и назначение

Сигнатура:

public static <T> Collector<T, ?, Integer> summingInt(ToIntFunction<? super T> mapper)

Где:

mapper — функция, преобразующая элемент потока в int (значение, которое нужно суммировать)
Возвращает коллектор, который применяет эту функцию ко всем элементам и суммирует результаты

Пример:

List<Product> products = List.of(
    new Product("Laptop", 1000),
    new Product("Phone", 500),
    new Product("Tablet", 300)
);

int totalPrice = products.stream()
    .collect(Collectors.summingInt(Product::getPrice));

// Результат: 1800 (1000 + 500 + 300)

2. Внутренняя реализация

Коллектор работает по следующему алгоритму:
Использует промежуточный аккумулятор типа int[] (для мутабельного накопления суммы)
Для каждого элемента применяет mapper и добавляет результат в аккумулятор
В конце возвращает итоговую сумму

3. Особенности и ограничения

3.1. Только для примитивных int

Для long используйте summingLong
Для double — summingDouble

3.2. Нет обработки null

Если mapper возвращает null, будет NullPointerException

3.3. Параллельные стримы

Корректно работает в параллельных стримах благодаря атомарному накоплению

4. Альтернативы

4.1. Через mapToInt() + sum()

Более прямолинейный способ:

int total = products.stream()
    .mapToInt(Product::getPrice)
    .sum();

Плюсы:
Чуть лучше производительность
Более явное преобразование типов

Минусы:
Нельзя использовать в комбинации с другими коллекторами (например, при группировке)

4.2. reduce()

int total = products.stream()
    .reduce(0, (sum, p) -> sum + p.getPrice(), Integer::sum);

5. Комбинирование с другими коллекторами

Особенно полезно в groupingBy для агрегации:

Map<String, Integer> totalPriceByCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::getCategory,
        Collectors.summingInt(Product::getPrice)
    ));

Пример вывода:

{
  "Electronics": 1800,
  "Office": 750
}

6. Производительность

Для примитивов (summingInt) работает быстрее, чем reduce с Integer
В HotSpot JIT-компилятор может оптимизировать до прямого сложения

#Java #Training #Medium #Collectors #summingInt

140 views05:59

Java for Beginner

Что выведет код?

import java.util.*;

public class Task290425 {
    public static void main(String[] args) {
        Set<Integer> set1 = new HashSet<>(Arrays.asList(1, 2, 3));
        Set<Integer> set2 = new HashSet<>(Arrays.asList(3, 2, 1));
        Set<Integer> set3 = new LinkedHashSet<>(Arrays.asList(1, 2, 3));
        
        System.out.println(set1.equals(set2));
        System.out.println(set1.equals(set3));
    }
}

#Tasks

150 views09:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

30 voters148 views09:48

Java for Beginner

Это после многодневной поддержки легаси кода, такой приход случается? 🧐 😃

https://t.me/Java_for_beginner_dev

#Mems

Please open Telegram to view this post

VIEW IN TELEGRAM

153 views11:44

Java for Beginner

Вопросы с собеседования 👩‍💻

Что такое WeakHashMap?

Anonymous Quiz

26%

Коллекция с сильными ссылками

57%

Коллекция, где ключи могут быть удалены сборщиком мусора

Отсортированный список

13%

Класс для работы с датами

46 voters144 views13:44

Java for Beginner

Collectors в Java

Collectors.joining

Collectors.joining – это специализированный коллектор для конкатенации строковых представлений элементов потока в единую строку. Это мощный инструмент для работы с текстовыми данными в Java Stream API.

1. Базовая форма: joining()

Конкатенирует элементы без разделителей.

Сигнатура:

public static Collector<CharSequence, ?, String> joining()

Пример:

List<String> words = List.of("Java", "Stream", "API");
String result = words.stream().collect(Collectors.joining());

// Результат: "JavaStreamAPI"

Особенности:
Работает только с CharSequence (String, StringBuilder и др.)
Если поток пуст, возвращает пустую строку ""

2. С разделителем: joining(delimiter)

Добавляет указанный разделитель между элементами.

Сигнатура:

public static Collector<CharSequence, ?, String> joining(CharSequence delimiter)

Пример:

String result = words.stream().collect(Collectors.joining(", "));

// Результат: "Java, Stream, API"

Применение:
CSV-форматирование
Построение SQL-запросов
Логирование коллекций

3. Полная форма: joining(delimiter, prefix, suffix)

Добавляет префикс и суффикс к результату.

Сигнатура:

public static Collector<CharSequence, ?, String> joining(
    CharSequence delimiter,
    CharSequence prefix,
    CharSequence suffix
)

Пример:

String result = words.stream()
    .collect(Collectors.joining(", ", "[", "]"));

// Результат: "[Java, Stream, API]"

Типичные сценарии:
JSON-массивы: joining(", ", "[", "]")
SQL IN-условия: joining("', '", "'", "'") → 'Java', 'Stream', 'API'
Форматированные списки

4. Внутренняя реализация

Коллектор использует StringJoiner внутри:

StringJoiner joiner = new StringJoiner(delimiter, prefix, suffix);
stream.forEach(element -> joiner.add(element.toString()));
return joiner.toString();

Особенности работы:
Для пустого потока возвращает prefix + suffix (например, "[]")
Оптимизирован для String (избегает лишних преобразований)
В параллельных стримах работает корректно (слияние через StringJoiner.merge)

5. Работа с не-строковыми объектами

Если элементы не являются строками, нужно преобразовать их явно:

List<Integer> numbers = List.of(1, 2, 3);
String result = numbers.stream()
    .map(Object::toString)
    .collect(Collectors.joining("-"));

// Результат: "1-2-3"

Альтернатива через Collectors.mapping:

String result = numbers.stream()
    .collect(Collectors.mapping(
        Object::toString,
        Collectors.joining("/")
    ));

6. Ограничения и нюансы

Null-элементы:
Вызывают NullPointerException

Решение – фильтрация:

.filter(Objects::nonNull)

Большие объемы данных:
Для гигантских потоков лучше использовать StringBuilder напрямую

Локализация:
Нет встроенной поддержки (для чисел/дат используйте NumberFormat перед joining)

7. Комбинирование с другими коллекторами

Группировка с объединением:

Map<String, String> joinedByCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::getCategory,
        Collectors.mapping(
            Product::getName,
            Collectors.joining(", ")
        )
    ));

Результат:

{
  "Electronics": "Laptop, Phone",
  "Office": "Pen, Paper"
}

Многоуровневое объединение:

String complex = persons.stream()
    .collect(Collectors.mapping(
        p -> p.name() + " (" + p.age() + ")",
        Collectors.joining("; ", "Persons: ", ".")
    ));

// Результат: "Persons: Alice (25); Bob (30)."

8. Альтернативы

StringBuilder (для сложных сценариев):

StringBuilder sb = new StringBuilder();
list.forEach(sb::append);

String.join() (только для List<String>):

String.join(", ", words);

TextBlocks (Java 15+ для многострочных данных):

String sql = """
    SELECT %s
    FROM table
    WHERE id IN (%s)
    """.formatted(
        columns.stream().collect(joining(", ")),
        ids.stream().map(Object::toString).collect(joining(", "))
    );

#Java #Training #Medium #Collectors #joining

140 views14:59

Java for Beginner

Please open Telegram to view this post

VIEW IN TELEGRAM

136 views01:59

Java for Beginner

Please open Telegram to view this post

VIEW IN TELEGRAM

141 views03:59

Java for Beginner

Collectors в Java

Collectors.partitioningBy

Collectors.partitioningBy – это специальный коллектор, который разделяет элементы потока на две группы с помощью предиката.

Результатом всегда является Map<Boolean, List<T>>, где:
true – элементы, удовлетворяющие условию
false – элементы, не удовлетворяющие условию

1. Базовая форма: partitioningBy(predicate)
Разделяет элементы на две группы без дополнительной обработки.

Сигнатура:

public static <T> Collector<T, ?, Map<Boolean, List<T>>> partitioningBy(
    Predicate<? super T> predicate
)

Пример:

List<Integer> numbers = List.of(1, 2, 3, 4, 5);

Map<Boolean, List<Integer>> partitioned = numbers.stream()
    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

// Результат:
// {
//   false=[1, 3, 5],
//   true=[2, 4]
// }

Особенности:
Всегда возвращает обе группы (даже если одна пустая)
Сохраняет порядок элементов, если поток упорядочен

2. Расширенная форма: partitioningBy(predicate, downstream)
Позволяет дополнительно обработать каждую группу с помощью другого коллектора.

Сигнатура:

public static <T, D, A> Collector<T, ?, Map<Boolean, D>> partitioningBy(
    Predicate<? super T> predicate,
    Collector<? super T, A, D> downstream
)

Примеры применения:

2.1. Подсчет количества элементов в каждой группе

Map<Boolean, Long> countByPartition = numbers.stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.counting()
    ));

// Результат: {false=3, true=2}

2.2. Объединение элементов в строку

Map<Boolean, String> joinedPartitions = numbers.stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.mapping(
            Object::toString,
            Collectors.joining("-")
        )
    ));

// Результат: {false="1-3-5", true="2-4"}

2.3. Группировка в Set вместо List

Map<Boolean, Set<Integer>> toSet = numbers.stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.toSet()
    ));

3. Внутренняя реализация
Коллектор работает по следующему алгоритму:
Создает Map<Boolean, List<T>> с двумя ключами (true/false)
Для каждого элемента применяет предикат и добавляет в соответствующую группу
Если указан downstream-коллектор, применяет его к каждой группе

Псевдокод реализации:

Map<Boolean, A> result = new HashMap<>();
result.put(true, new ArrayList<>());
result.put(false, new ArrayList<>());

stream.forEach(item -> {
    boolean key = predicate.test(item);
    result.get(key).add(item);
});

// Если есть downstream:
result.replaceAll((k, v) -> downstream.finisher().apply(v));

4. Практические примеры
4.1. Разделение пользователей по возрасту

record Person(String name, int age) {}

List<Person> people = List.of(
    new Person("Alice", 25),
    new Person("Bob", 17),
    new Person("Charlie", 30)
);

Map<Boolean, List<Person>> adults = people.stream()
    .collect(Collectors.partitioningBy(p -> p.age() >= 18));

// Результат:
// {
//   false=[Person[name=Bob, age=17]],
//   true=[Person[name=Alice, age=25], Person[name=Charlie, age=30]]
// }

4.2. Статистика по разделенным группам

Map<Boolean, IntSummaryStatistics> stats = numbers.stream()
    .collect(Collectors.partitioningBy(
        n -> n % 2 == 0,
        Collectors.summarizingInt(Integer::intValue)
    ));

// Получить среднее для четных чисел:
double avgEven = stats.get(true).getAverage();

5. Ограничения и нюансы
Неизменяемость результатов:
Возвращаемые коллекции можно модифицировать (обычно ArrayList)

Для неизменяемых групп использовать collectingAndThen:

.collect(Collectors.collectingAndThen(
    Collectors.partitioningBy(predicate),
    Collections::unmodifiableMap
));

Параллельные стримы:
Работает корректно в параллельных стримах
Группы объединяются через Map.merge

Null-значения:
Предикат должен обрабатывать null (иначе NPE)

Решение:

.partitioningBy(item -> item != null && predicate.test(item))

#Java #Training #Medium #Collectors #partitioningBy

142 views05:59

Java for Beginner

Что выведет код?

import java.util.*;

public class Task300425 {
    public static void main(String[] args) {
        short a = 1;
        int i = 1;
        long k = 1;

        Map<Object, String> map = new HashMap<>();
        map.put(i, "Java");
        map.put(k, "Python");
        map.put(a, "C++");

        System.out.println(map.size());
    }
}

#Tasks

138 views09:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

29 voters130 views09:48

Java for Beginner

#Mems. Небольшое несоответствие получилось.

199 views09:55

Java for Beginner

Тут много нюансов...😂😂😂

https://t.me/Java_for_beginner_dev

#Mems

127 views11:44

Java for Beginner

Вопросы с собеседования 👩‍💻

Что такое Vector?

Anonymous Quiz

21%

Массив фиксированного размера

13%

Коллекция уникальных элементов

64%

Устаревшая синхронизированная реализация списка

Класс для работы с файлами

39 voters122 views13:44

Java for Beginner

Collectors в Java

Collectors.collectingAndThen

Collectors.collectingAndThen – это особый коллектор, который добавляет финальное преобразование к результату другого коллектора. Это мощный инструмент для пост-обработки данных после сбора.

1. Базовая концепция

Сигнатура:

public static <T, A, R, RR> Collector<T, A, RR> collectingAndThen(
    Collector<T, A, R> downstream,
    Function<R, RR> finisher
)

Где:
downstream – основной коллектор (например, toList, groupingBy)
finisher – функция, применяемая к результату коллектора
RR – новый тип возвращаемого значения

2. Простые примеры

2.1. Создание неизменяемого списка

List<String> immutableList = stream
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        Collections::unmodifiableList
    ));

2.2. Получение первого элемента

String firstItem = stream
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        list -> list.isEmpty() ? null : list.get(0)
    );

3. Комбинация с другими коллекторами

3.1. Группировка с неизменяемыми значениями

Map<String, List<Integer>> unmodifiableGroups = numbers.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.groupingBy(
            n -> n % 2 == 0 ? "even" : "odd"
        ),
        Collections::unmodifiableMap
    ));

3.2. Подсчет с дополнительной проверкой

Long countOrZero = stream
    .collect(Collectors.collectingAndThen(
        Collectors.counting(),
        c -> c > 100 ? c : 0L
    ));

4. Внутренняя реализация

Принцип работы:
Сначала выполняется основной коллектор (downstream)
Затем к его результату применяется finisher
Возвращается преобразованное значение

Псевдокод:

R intermediateResult = downstream.collect(stream);
RR finalResult = finisher.apply(intermediateResult);
return finalResult;

5. Практические применения

5.1. Безопасное извлечение Optional

Optional<String> lastElement = stream
    .collect(Collectors.collectingAndThen(
        Collectors.toList(),
        list -> list.isEmpty() 
            ? Optional.empty() 
            : Optional.of(list.get(list.size()-1))
    );

5.2. Нормализация данных после группировки

Map<String, Set<String>> caseInsensitiveGroups = words.stream()
    .collect(Collectors.collectingAndThen(
        Collectors.groupingBy(
            String::toLowerCase,
            Collectors.toSet()
        ),
        Collections::unmodifiableMap
    ));

6. Особенности и ограничения

Порядок выполнения:
Сначала полностью выполняется downstream-коллектор
Затем применяется finisher

Параллельные стримы:
Работает корректно, если finisher – thread-safe

Null-обработка:
Finisher должен сам обрабатывать null-значения

7. Производительность

Обычно добавляет незначительные накладные расходы:
5-10% к времени выполнения базового коллектора
В HotSpot часто инлайнится JIT-компилятором

#Java #Training #Medium #Collectors #partitioningBy

128 views14:59

Java for Beginner

Please open Telegram to view this post

VIEW IN TELEGRAM

113 views01:59

About

Blog

Apps

Platform