Java for Beginner

Collectors в Java

Collectors.toList

Collectors.toList() собирает элементы потока в List. Реализация по умолчанию возвращает ArrayList, но конкретная реализация не гарантируется и может измениться. Это один из самых простых и часто используемых коллекторов.

Пример:

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ToListExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("apple", "banana", "orange");
        List<String> list = stream.collect(Collectors.toList());
        System.out.println(list); // [apple, banana, orange]
    }
}

Внутренне toList использует:
Supplier: new ArrayList<>()
Accumulator: list.add(element)
Combiner: list1.addAll(list2)
Finisher: возвращает сам аккумулятор (identity функция).

Особенности:
Сохраняет порядок элементов (если поток упорядочен).
Допускает дубликаты.
Не поддерживает настройку типа List (для этого есть toCollection).

Collectors.toSet

Collectors.toSet() собирает элементы потока в Set, по умолчанию возвращая HashSet. Как и в случае с toList, конкретная реализация не гарантируется.

Пример:

import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ToSetExample {
    public static void main(String[] args) {
        Stream<String> stream = Stream.of("apple", "banana", "apple");
        Set<String> set = stream.collect(Collectors.toSet());
        System.out.println(set); // [apple, banana]
    }
}

Внутренне toSet использует:
Supplier: new HashSet<>()
Accumulator: set.add(element)
Combiner: set1.addAll(set2)
Finisher: возвращает аккумулятор.

Особенности:
Удаляет дубликаты (Set не допускает повторяющихся элементов).
Не гарантирует порядок элементов (HashSet не сохраняет порядок).
Для упорядоченного множества можно использовать toCollection(TreeSet::new).

#Java #Training #Medium #Collectors #CollectorsToList #CollectorsToSet

130 views14:59

Java for Beginner

Collectors в Java

Collectors.toMap

Collectors.toMap – это мощный коллектор, преобразующий элементы потока в Map<K, V>, где ключи и значения вычисляются на основе элементов потока.

1. Базовая форма: toMap(keyMapper, valueMapper)

Преобразует поток в Map, где:
keyMapper – функция, вычисляющая ключ,
valueMapper – функция, вычисляющая значение.

Сигнатура:

public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(  
    Function<? super T, ? extends K> keyMapper,  
    Function<? super T, ? extends U> valueMapper  
)

Пример:

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

// Создаем Map: {имя -> длина строки}  
Map<String, Integer> nameToLength = names.stream()  
    .collect(Collectors.toMap(  
        name -> name,            // ключ – сама строка  
        name -> name.length()    // значение – длина строки  
    ));  

// Результат: {"Alice":5, "Bob":3, "Charlie":7}
Что произойдет, если ключи повторяются?
→ Будет выброшено IllegalStateException!

2. Обработка дубликатов: toMap(keyMapper, valueMapper, mergeFunction)

Если возможны повторяющиеся ключи, нужно указать mergeFunction – стратегию разрешения конфликтов.

Сигнатура:

public static <T, K, U> Collector<T, ?, Map<K, U>> toMap(  
    Function<? super T, ? extends K> keyMapper,  
    Function<? super T, ? extends U> valueMapper,  
    BinaryOperator<U> mergeFunction  
)

Примеры:

2.1. Оставить старое значение

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

Map<String, Integer> nameToLength = names.stream()  
    .collect(Collectors.toMap(  
        name -> name,  
        name -> name.length(),  
        (oldValue, newValue) -> oldValue  // при конфликте берем старое значение  
    ));  

// Результат: {"Alice":5, "Bob":3}

2.2. Объединить значения (например, конкатенация строк)

List<String> names = List.of("A", "B", "A", "C");  

Map<String, String> mergedLetters = names.stream()  
    .collect(Collectors.toMap(  
        letter -> letter,  
        letter -> letter,  
        (oldVal, newVal) -> oldVal + newVal  // "A" + "A" → "AA"  
    ));  

// Результат: {"A":"AA", "B":"B", "C":"C"}

2.3. Суммирование значений при дублировании ключей

record Product(String id, double price) {}  

List<Product> products = List.of(  
    new Product("A", 10.0),  
    new Product("B", 20.0),  
    new Product("A", 15.0)  
);  

Map<String, Double> totalPriceById = products.stream()  
    .collect(Collectors.toMap(  
        Product::id,  
        Product::price,  
        Double::sum  // 10.0 + 15.0 = 25.0  
    ));  

// Результат: {"A":25.0, "B":20.0}

3. Выбор реализации Map: toMap(keyMapper, valueMapper, mergeFunction, mapFactory)

Позволяет указать конкретную реализацию Map (например, LinkedHashMap или TreeMap).

Сигнатура:

public static <T, K, U, M extends Map<K, U>> Collector<T, ?, M> toMap(  
    Function<? super T, ? extends K> keyMapper,  
    Function<? super T, ? extends U> valueMapper,  
    BinaryOperator<U> mergeFunction,  
    Supplier<M> mapFactory  
)

Примеры:

3.1. Сохранение порядка вставки (LinkedHashMap)

Map<String, Integer> orderedMap = names.stream()  
    .collect(Collectors.toMap(  
        name -> name,  
        name -> name.length(),  
        (oldVal, newVal) -> oldVal,  
        LinkedHashMap::new  
    ));

3.2. Сортировка по ключу (TreeMap)

Map<String, Integer> sortedMap = names.stream()  
    .collect(Collectors.toMap(  
        name -> name,  
        name -> name.length(),  
        (oldVal, newVal) -> oldVal,  
        TreeMap::new  
    ));

#Java #Training #Medium #Collectors #CollectorsToMap

121 views05:59

Java for Beginner

4. Особенности и подводные камни

4.1. Null-ключи и Null-значения
HashMap допускает один null-ключ, но если keyMapper возвращает null – будет NullPointerException.
Если valueMapper возвращает null, значение в Map будет null.

4.2. Параллельные стримы
toMap не оптимизирован для параллельных операций.
Вместо него лучше использовать Collectors.toConcurrentMap.

4.3. Изменяемые ключи
Если ключ изменяется после добавления в Map, это может нарушить работу HashMap (ключи должны быть immutable).

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

5.1. Collectors.toUnmodifiableMap (Java 10+)
Создает неизменяемую Map:

Map<String, Integer> unmodifiableMap = names.stream()  
    .collect(Collectors.toUnmodifiableMap(  
        name -> name,  
        name -> name.length()  
    ));

5.2. Collectors.toConcurrentMap
Оптимизирован для многопоточности:

ConcurrentMap<String, Integer> concurrentMap = names.stream()  
    .collect(Collectors.toConcurrentMap(  
        name -> name,  
        name -> name.length()  
    ));

#Java #Training #Medium #Collectors #CollectorsToMap

123 views05:59

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

139 views14:59

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

139 views05:59

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

139 views14: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

141 views05:59

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

126 views14:59

Java for Beginner

Collectors в Java

Collectors.reducing

Collectors.reducing – это универсальный коллектор для выполнения операций свертки (reduction) над элементами потока. Он предоставляет более гибкую альтернативу встроенным операциям типа sum(), max() и min(), позволяя задавать собственную логику агрегации.

1. Три формы reducing
1.1. Базовая форма (с identity, mapper и операцией)

public static <T, U> Collector<T, ?, U> reducing(
    U identity,
    Function<? super T, ? extends U> mapper,
    BinaryOperator<U> op
)

Параметры:
identity – начальное значение (аналог "нейтрального элемента")
mapper – функция преобразования элемента перед обработкой
op – операция для объединения двух значений

Пример (сумма длин строк):

List<String> words = List.of("Java", "Stream", "API");
int totalLength = words.stream()
    .collect(Collectors.reducing(
        0,                  // identity
        String::length,     // mapper
        Integer::sum        // op
    ));
// Результат: 11 (4 + 6 + 1)

1.2. Упрощенная форма (с identity и операцией)

public static <T> Collector<T, ?, T> reducing(
    T identity,
    BinaryOperator<T> op
)

Пример (конкатенация строк):

String concatenated = words.stream()
    .collect(Collectors.reducing(
        "",         // identity
        String::concat
    ));
// Результат: "JavaStreamAPI"

1.3. Минималистичная форма (только операция)

public static <T> Collector<T, ?, Optional<T>> reducing(
    BinaryOperator<T> op
)

Пример (поиск максимального числа):

Optional<Integer> max = Stream.of(3, 1, 4)
    .collect(Collectors.reducing(
        Integer::max
    ));
// Результат: Optional[4]

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

Принцип работы:
Для каждого элемента применяет mapper (если указан)

Накопление результата через op:

// Псевдокод реализации
U result = identity;
for (T element : stream) {
    result = op.apply(result, mapper.apply(element));
}
return result;
Для формы без identity использует Optional для обработки пустых потоков

3. Практические примеры
3.1. Сложная агрегация объектов

record Product(String name, double price) {}

List<Product> products = List.of(
    new Product("Laptop", 999.99),
    new Product("Phone", 599.99)
);

// Сумма цен продуктов с названием длиннее 4 символов
double total = products.stream()
    .collect(Collectors.reducing(
        0.0,
        p -> p.name().length() > 4 ? p.price() : 0,
        Double::sum
    ));

3.2. Комбинация с groupingBy

// Максимальная цена в каждой категории
Map<String, Optional<Product>> byCategory = products.stream()
    .collect(Collectors.groupingBy(
        Product::category,
        Collectors.reducing((p1, p2) -> 
            p1.price() > p2.price() ? p1 : p2
    ));

3.3. Кастомная агрегация

// Пользовательская свертка для статистики
class Stats {
    int count;
    double sum;
    // + конструкторы/методы
}

Stats stats = stream.collect(Collectors.reducing(
    new Stats(0, 0.0),
    num -> new Stats(1, num),
    (s1, s2) -> new Stats(
        s1.count + s2.count,
        s1.sum + s2.sum
    )
));

4. Ограничения и нюансы
Параллельные стримы:
Требует ассоциативности операции ((a op b) op c == a op (b op c))
Пример ассоциативных операций: сложение, умножение, min/max
Неассоциативные: вычитание, деление

Null-значения:
identity не может быть null
Операция должна обрабатывать null, если mapper может его вернуть

Производительность:
Чуть медленнее специализированных коллекторов (summingInt и др.)
На 10-15% медленнее прямого reduce для примитивов

5. Альтернативы
Когда лучше использовать другие методы:

Для примитивов:

// Вместо:
.collect(reducing(0, Integer::sum))

// Лучше:
.mapToInt().sum()

Для стандартных операций:

// Вместо:
.collect(reducing(Integer::max))

// Лучше:
.max(Comparator.naturalOrder())

Для неизменяемых коллекций:

// Вместо:
.collect(reducing(Collections.emptyList(), customMerge))

// Лучше:
.collect(toUnmodifiableList())

#Java #Training #Medium #Collectors #reducing

123 views05:59

Java for Beginner

Collectors в Java

Кастомные коллекторы и неизменяемые коллекции

1. Создание кастомных коллекторов

Коллектор реализует интерфейс Collector<T, A, R>, где:
T – тип элементов потока
A – тип аккумулятора (промежуточное хранилище)
R – тип результата

Компоненты коллектора:
Supplier<A> – создает контейнер для накопления
BiConsumer<A, T> – добавляет элемент в контейнер
BinaryOperator<A> – объединяет частичные результаты (для параллельных стримов)
Function<A, R> – преобразует аккумулятор в результат
Characteristics (опционально) – набор характеристик (CONCURRENT, UNORDERED, IDENTITY_FINISH)

Пример: Кастомный коллектор для объединения строк с разделителем

Collector<String, StringBuilder, String> joinStrings = Collector.of(
    StringBuilder::new,            // supplier
    (sb, str) -> {                // accumulator
        if (!sb.isEmpty()) sb.append(", ");
        sb.append(str);
    },
    (sb1, sb2) -> {               // combiner (для параллельных стримов)
        if (sb1.length() > 0 && sb2.length() > 0) {
            sb1.append(", ");
        }
        return sb1.append(sb2);
    },
    StringBuilder::toString       // finisher
);

String result = Stream.of("Java", "Kotlin", "Scala")
    .collect(joinStrings);

// Результат: "Java, Kotlin, Scala"

2. Неизменяемые коллекции

Java 10+ предоставляет встроенные коллекторы для неизменяемых коллекций:

2.1. Стандартные неизменяемые коллекторы

List<String> unmodifiableList = stream.collect(Collectors.toUnmodifiableList());
Set<String> unmodifiableSet = stream.collect(Collectors.toUnmodifiableSet());
Map<String, Integer> unmodifiableMap = stream.collect(
    Collectors.toUnmodifiableMap(
        keyMapper,
        valueMapper,
        mergeFunction // для обработки дубликатов
    )
);

2.2. Создание через collectingAndThen

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

3. Комбинирование подходов

3.1. Неизменяемый кастомный коллектор

Collector<String, List<String>, List<String>> toImmutableList = Collector.of(
    ArrayList::new,               // supplier
    List::add,                    // accumulator
    (left, right) -> {            // combiner
        left.addAll(right);
        return left;
    },
    Collections::unmodifiableList // finisher
);

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

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

4. Особенности реализации

4.1. Параллельная обработка
Кастомные коллекторы должны иметь thread-safe аккумулятор или характеристику CONCURRENT
Combiner должен корректно объединять частичные результаты

4.2. Оптимизации
Для примитивов используйте специализированные коллекторы (summingInt, averagingDouble)
Избегайте boxing/unboxing в кастомных коллекторах

4.3. Обработка null
Встроенные неизменяемые коллекторы бросают NullPointerException при null-элементах

Решение:

.filter(Objects::nonNull)
.collect(toUnmodifiableList())

Когда создавать кастомные коллекторы:
✔️ Для сложной логики агрегации
✔️ Когда встроенные коллекторы не подходят
✔️ Для оптимизации производительности в специфичных сценариях

Когда использовать неизменяемые коллекции:
✔️ Для безопасного возврата результатов из методов
✔️ В многопоточных сценариях
✔️ Для защиты данных от модификации

#Java #Training #Medium #Collectors

136 views14:59

Java for Beginner

Jackson

В мире Java-программирования одна из самых частых задач — это работа с JSON. Будь то обмен данными между сервером и клиентом, интеграция с внешними API или хранение конфигураций — JSON стал стандартом де-факто. Именно для этих целей и был создан Jackson.

Что такое Jackson

Jackson — это одна из самых популярных Java-библиотек для работы с JSON. Она позволяет сериализовать объекты Java в JSON и обратно — десериализовать JSON в Java-объекты. Причем делает это быстро, эффективно и с минимальными накладными расходами.

Быстрая история

2007 год — Джейсон Т. Смит (Jason T. Smith) начал разработку Jackson.
2009 год — Первый стабильный релиз (Jackson 1.x).
2012 год — Выпуск Jackson 2.0 с полностью переработанным API.
Сейчас — Jackson активно поддерживается, последняя версия (на 2024 год) — Jackson 2.16+.

Где используется Jackson

Сегодня Jackson используется практически везде, где в Java-приложениях требуется работа с JSON:
В REST API на базе Spring Boot и других фреймворков
В микросервисной архитектуре для обмена данными между сервисами
При интеграции с внешними веб-сервисами
Для сохранения и чтения конфигураций в формате JSON
В тестировании при генерации или проверке JSON-структур
Многие крупные компании и проекты строят на Jackson свою работу с данными. Более того, Spring Framework по умолчанию использует Jackson для сериализации и десериализации JSON, что дополнительно укрепило его позиции.

Почему Jackson так популярен

Есть несколько причин, почему Jackson стал стандартом:

Производительность
Jackson славится своей высокой скоростью работы, что критично при обработке больших объемов данных.

Простота использования
Для базовых операций достаточно создать один экземпляр ObjectMapper и вызвать пару методов. В большинстве случаев не нужно писать дополнительный код.

Гибкость
Jackson поддерживает тонкую настройку через аннотации и внешнюю конфигурацию. Можно легко адаптировать сериализацию под любые требования.

Расширяемость
Jackson предлагает богатую экосистему модулей: поддержка новых типов данных (например, Java 8 Date/Time API), работа с CBOR, XML, YAML и другими форматами.

Интеграция с фреймворками
Такие популярные решения как Spring Boot, Dropwizard и многие другие "из коробки" работают с Jackson.

#Java #Training #Medium #Jackson

141 views05:59

Java for Beginner

Jackson. Быстрая сериализация и десериализация объектов

Работа с JSON в Jackson строится вокруг главного класса — ObjectMapper. Это основной инструмент для конвертации Java-объектов в JSON и обратно.

ObjectMapper: главный рабочий инструмент

ObjectMapper — это универсальный класс, предоставляющий удобные методы для:
Сериализации (преобразования объекта в JSON)
Десериализации (преобразования JSON обратно в объект)

Создание экземпляра максимально простое:

ObjectMapper objectMapper = new ObjectMapper();

Сериализация объекта в JSON

Сериализация — это процесс превращения Java-объекта в строку JSON.

Рассмотрим пример:

import com.fasterxml.jackson.databind.ObjectMapper;

public class Main {
    public static void main(String[] args) throws Exception {
        ObjectMapper objectMapper = new ObjectMapper();
        
        User user = new User("Alice", 25);
        
        String jsonString = objectMapper.writeValueAsString(user);
        System.out.println(jsonString);
    }
}

class User {
    private String name;
    private int age;
    
    public User() {
    }

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

    // Геттеры и сеттеры обязательны для Jackson
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Результат работы программы:

{"name":"Alice","age":25}

writeValueAsString превращает объект в строку JSON. Можно также сохранить результат сразу в файл через writeValue(new File("user.json"), user).

Десериализация JSON в объект

Десериализация — это обратный процесс: превращение JSON-строки в объект Java.

Пример:

String jsonInput = "{\"name\":\"Bob\",\"age\":30}";

User user = objectMapper.readValue(jsonInput, User.class);

System.out.println(user.getName()); // Выведет: Bob
System.out.println(user.getAge());  // Выведет: 30

readValue принимает JSON и класс, в который нужно преобразовать данные. Важно, чтобы у целевого класса был публичный конструктор без параметров и стандартные геттеры/сеттеры.

На что обратить внимание

🔹 Обязательны геттеры/сеттеры или public-поля (иначе Jackson не увидит поля).
🔹 Пустой конструктор нужен для десериализации.
🔹 Имена полей JSON и Java должны совпадать (или использовать аннотации, об этом в след. посте).
🔹 Обработка исключений — методы writeValueAsString() и readValue() могут выбросить JsonProcessingException.

#Java #Training #Medium #Jackson

122 views14:59

Java for Beginner

Jackson

Ключевые аннотации для сериализации.

Jackson предоставляет богатый набор аннотаций для управления тем, как Java-объекты сериализуются в JSON. На практике чаще всего используются три основные аннотации: @JsonProperty, @JsonIgnore и @JsonInclude.

@JsonProperty

Аннотация @JsonProperty позволяет задать имя поля в итоговом JSON независимо от имени переменной в Java-классе. Это особенно полезно, если требуется соблюдать определенные соглашения об именовании в JSON (например, использовать snake_case).

Пример:

import com.fasterxml.jackson.annotation.JsonProperty;

public class User {
    @JsonProperty("user_name")
    private String name;

    private int age;

    public User() {}

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

    // Геттеры и сеттеры
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

При сериализации объект будет выглядеть так:

{"user_name":"Alice","age":25}

Без @JsonProperty имя поля в JSON было бы "name", но аннотация позволила задать собственное имя.

@JsonIgnore

Аннотация @JsonIgnore используется для исключения полей из сериализации и десериализации. Если поле не должно попадать в JSON-вывод или не должно учитываться при чтении JSON, достаточно добавить эту аннотацию.

Пример:

import com.fasterxml.jackson.annotation.JsonIgnore;

public class User {
    private String name;
    
    @JsonIgnore
    private String password;

    public User() {}

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

    // Геттеры и сеттеры
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

Результат сериализации:

{"name":"Alice"}

Поле password полностью исключено из JSON.

@JsonInclude

Аннотация @JsonInclude позволяет управлять включением полей в JSON в зависимости от их значения. Например, можно настроить сериализацию так, чтобы поля с null не попадали в итоговый JSON.

Пример:

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class User {
    private String name;
    private String email;

    public User() {}

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

    // Геттеры и сеттеры
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

Если email будет null, результат сериализации будет таким:

{"name":"Alice"}

Без @JsonInclude поле email также попало бы в JSON с null значением.

#Java #Training #Medium #Jackson #JsonProperty #JsonIgnore #JsonInclude

151 viewsedited 05:59

Java for Beginner

Jackson

Аннотации Jackson для десериализации и изменения структуры JSON

Иногда структура входящего JSON не совпадает напрямую с полями Java-объекта. Для корректной десериализации в таких случаях Jackson предлагает ряд аннотаций, среди которых особенно важны @JsonCreator, @JsonSetter и @JsonAlias.

@JsonCreator

Аннотация @JsonCreator позволяет указать, какой именно конструктор или фабричный метод должен использоваться для создания объекта из JSON.
Особенно полезна в случаях, когда объект должен быть создан через специфический конструктор, а не через пустой и геттеры/сеттеры.

Пример:

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

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

    @JsonCreator
    public User(@JsonProperty("name") String name, 
                @JsonProperty("age") int age) {
        this.name = name;
        this.age = age;
    }

    // Только геттеры
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

При десериализации Jackson использует указанный конструктор, а не требует пустой конструктор и сеттеры:

String json = "{\"name\":\"Alice\",\"age\":30}";
User user = objectMapper.readValue(json, User.class);

@JsonSetter

Аннотация @JsonSetter указывается на методе и сообщает Jackson, что данный метод должен использоваться для установки значения при десериализации.
Это полезно, когда метод сеттера отличается по названию от поля или нужно выполнить какую-то дополнительную обработку значения.

Пример:

import com.fasterxml.jackson.annotation.JsonSetter;

public class Product {
    private String name;

    public Product() {}

    public String getName() {
        return name;
    }

    @JsonSetter("product_name")
    public void setName(String name) {
        this.name = name.toUpperCase();
    }
}

JSON:

{
  "product_name": "laptop"
}

При десериализации будет вызван метод setName, а имя продукта будет автоматически приведено к верхнему регистру: "LAPTOP".

@JsonAlias

Аннотация @JsonAlias позволяет указывать альтернативные имена полей, которые могут приходить в JSON. Это особенно полезно для работы с нестабильными или изменяющимися API.

Пример:

import com.fasterxml.jackson.annotation.JsonAlias;

public class Customer {
    @JsonAlias({"user_name", "login"})
    private String username;

    public Customer() {}

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

Теперь следующий JSON будет корректно обработан:

{ "user_name": "admin" }

или

{ "login": "admin" }

И в обоих случаях значение попадет в поле username.

Пример нестандартного маппинга

Иногда API может менять структуру данных или использовать разные названия для одного и того же поля. Комбинируя @JsonCreator, @JsonProperty и @JsonAlias, можно добиться правильной обработки даже самых нестандартных случаев.

Например:

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonAlias;

public class Employee {
    private final String id;
    private final String fullName;

    @JsonCreator
    public Employee(@JsonProperty("id") String id,
                    @JsonProperty("full_name") @JsonAlias({"name", "fullname"}) String fullName) {
        this.id = id;
        this.fullName = fullName;
    }

    public String getId() {
        return id;
    }

    public String getFullName() {
        return fullName;
    }
}

Теперь Jackson корректно обработает JSON, где имя сотрудника приходит под разными ключами: full_name, name или fullname.

#Java #Training #Medium #Jackson #JsonCreator #JsonSetter #JsonAlias

135 views14:59

Java for Beginner

Jackson

Работа со списками, картами и вложенными объектами

JSON — это не только простые объекты, но и сложные структуры: списки, словари, вложенные объекты. В этом посте разберем, как Jackson справляется с такими случаями, и как правильно сериализовать и десериализовать коллекции и составные структуры.

Списки объектов

Представим, что у нас есть список пользователей:

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

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

    // Геттеры и сеттеры
}

Сериализация списка в JSON:

List<User> users = List.of(
    new User("Alice", 30),
    new User("Bob", 25)
);

String json = objectMapper.writeValueAsString(users);
System.out.println(json);

Результат:

[
  {"name":"Alice","age":30},
  {"name":"Bob","age":25}
]

Десериализация списка обратно в Java:

String jsonInput = "[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":25}]";

List<User> users = objectMapper.readValue(
    jsonInput,
    new TypeReference<List<User>>() {}
);
Здесь важно использовать TypeReference, чтобы сохранить информацию о типе во время десериализации.

Карты (мапы)

JSON-объект с произвольными ключами часто удобно мапить в Map<String, Object>.

Например:

{
  "name": "Alice",
  "age": 30,
  "active": true
}

Можно прочитать в Map:

String json = "{\"name\":\"Alice\",\"age\":30,\"active\":true}";

Map<String, Object> map = objectMapper.readValue(json, new TypeReference<Map<String, Object>>() {});

Сериализация карты обратно:

Map<String, Object> data = new HashMap<>();
data.put("name", "Alice");
data.put("age", 30);
data.put("active", true);

String jsonOutput = objectMapper.writeValueAsString(data);

Вложенные объекты

Вложенные структуры — это JSON, где одно поле содержит объект:

{
  "id": 1,
  "user": {
    "name": "Alice",
    "age": 30
  }
}

Соответствующий Java-класс:

public class Wrapper {
    private int id;
    private User user;

    public Wrapper() {}
    public Wrapper(int id, User user) {
        this.id = id;
        this.user = user;
    }

    // Геттеры и сеттеры
}

Jackson автоматически корректно сериализует и десериализует такие вложенные объекты:

Wrapper wrapper = new Wrapper(1, new User("Alice", 30));
String json = objectMapper.writeValueAsString(wrapper);

Результат:

{
  "id": 1,
  "user": {
    "name": "Alice",
    "age": 30
  }
}

И обратно:

String input = "{\"id\":1,\"user\":{\"name\":\"Alice\",\"age\":30}}";
Wrapper wrapper = objectMapper.readValue(input, Wrapper.class);

Комбинирование структур

Jackson легко справляется с комбинацией вложенных объектов, списков и мап:

{
  "group": "admins",
  "members": [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25}
  ],
  "meta": {
    "created": "2023-10-01",
    "active": true
  }
}

Нужно лишь правильно описать классы:

public class Group {
    private String group;
    private List<User> members;
    private Map<String, Object> meta;

    // Конструктор, геттеры, сеттеры
}

#Java #Training #Medium #Jackson

118 views05:59

Java for Beginner

Jackson

Кастомные десериализаторы

Иногда структура входящего JSON или требования к обработке данных слишком специфичны, и стандартной десериализации Jackson оказывается недостаточно. В таких случаях можно реализовать собственный десериализатор, унаследовавшись от JsonDeserializer.

Когда нужен кастомный десериализатор
— Нужно преобразовать нестандартный формат данных
— Нужно добавить проверку, валидацию, нормализацию
— Нужно маппить одно поле в несколько
— Нужно логировать, фильтровать, трансформировать содержимое JSON

Шаг 1: Создание собственного десериализатора

Для этого создаем класс, расширяющий JsonDeserializer<T>:

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;

import java.io.IOException;

public class NameDeserializer extends JsonDeserializer<String> {
    @Override
    public String deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        String rawValue = p.getText();

        if (rawValue == null || rawValue.trim().isEmpty()) {
            throw new IOException("Имя не может быть пустым");
        }

        // Пример нормализации: первая буква заглавная
        return rawValue.substring(0, 1).toUpperCase() + rawValue.substring(1).toLowerCase();
    }
}

Шаг 2: Привязка десериализатора к полю

Теперь мы можем использовать наш кастомный десериализатор на нужном поле через аннотацию @JsonDeserialize.

import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

public class User {
    @JsonDeserialize(using = NameDeserializer.class)
    private String name;

    private int age;

    public User() {}

    // Геттеры и сеттеры
}

Шаг 3: Пример использования

String json = "{\"name\":\"  aLiCe  \", \"age\":30}";

User user = objectMapper.readValue(json, User.class);

System.out.println(user.getName()); // Выведет: Alice

Если в поле name будет пустая строка или только пробелы — Jackson выбросит исключение, как мы это настроили в десериализаторе.

Что ещё можно делать в кастомных десериализаторах

— Преобразовывать дату из нестандартного формата
— Разбирать строки с разделителями (например, CSV в List)
— Валидировать числовые диапазоны
— Преобразовывать строки в enum с логикой по умолчанию
— Обрабатывать null как спецзначения
— Инъектировать зависимости (через context.findInjectableValue())

#Java #Training #Medium #Jackson

132 views14:59

Java for Beginner

Jackson

Глобальная настройка ObjectMapper: как управлять сериализацией и десериализацией

Jackson предоставляет удобный способ централизованно настраивать поведение через ObjectMapper. Эта конфигурация позволяет управлять форматированием JSON, обработкой неизвестных полей, null-значений и множеством других аспектов.

Инициализация ObjectMapper

import com.fasterxml.jackson.databind.ObjectMapper;

ObjectMapper mapper = new ObjectMapper();
Можно использовать его напрямую или создать бин (например, в Spring).

1. Игнорирование неизвестных полей

По умолчанию Jackson выбросит исключение, если в JSON попадётся поле, которого нет в Java-классе.

Это можно отключить так:

import com.fasterxml.jackson.databind.DeserializationFeature;

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

Теперь лишние поля будут просто игнорироваться:

{
  "name": "Alice",
  "age": 30,
  "extra_field": "ignored"
}

2. Красивая печать JSON (Pretty Print)

По умолчанию JSON сериализуется в одну строку. Чтобы включить форматирование с отступами:

import com.fasterxml.jackson.databind.SerializationFeature;

mapper.enable(SerializationFeature.INDENT_OUTPUT);

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

{
  "name" : "Alice",
  "age" : 30
}
Это особенно полезно для логирования и отладки.

3. Исключение null-полей

Если нужно убрать из JSON все поля с null, можно настроить так:

import com.fasterxml.jackson.annotation.JsonInclude;

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

Пример:

public class User {
    public String name;
    public String email; // может быть null
}

Результат без email, если он null:

{
  "name": "Alice"
}

4. Ошибка при отсутствии обязательных полей

По умолчанию Jackson пропускает отсутствующие поля. Но можно требовать их наличия:

mapper.configure(DeserializationFeature.FAIL_ON_NULL_FOR_PRIMITIVES, true);
mapper.configure(DeserializationFeature.FAIL_ON_MISSING_CREATOR_PROPERTIES, true);

5. Написание чисел как строки

mapper.configure(SerializationFeature.WRITE_NUMBERS_AS_STRINGS, true);

Результат:

{
  "age": "30"
}

6. Установка глобального формата дат

import java.text.SimpleDateFormat;

mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd"));

Когда это полезно
— В проектах с нестабильными API
— При интеграции с фронтендом, где важно форматирование
— При логировании JSON в читаемом виде
— Для обеспечения устойчивости к изменяющимся данным

#Java #Training #Medium #Jackson #ObjectMapper

132 views05:59

Java for Beginner

Jackson

Использование модулей в Jackson: JavaTimeModule и работа с Java 8 датами

Начиная с Java 8, в язык была добавлена новая мощная модель работы со временем: LocalDate, LocalDateTime, Instant и другие типы из пакета java.time. Однако стандартная конфигурация Jackson не умеет корректно сериализовать и десериализовать эти типы "из коробки".

Проблема по умолчанию

Если попытаться сериализовать объект с полем LocalDateTime, Jackson выдаст ошибку или выведет нечитабельное представление (например, через timestamp).

Пример:

public class Event {
    public String name;
    public LocalDateTime dateTime;

    public Event() {}
    public Event(String name, LocalDateTime dateTime) {
        this.name = name;
        this.dateTime = dateTime;
    }
}

Event event = new Event("Conference", LocalDateTime.now());
String json = objectMapper.writeValueAsString(event);
Без дополнительных модулей Jackson не поймёт, как сериализовать LocalDateTime.

Решение: JavaTimeModule

Чтобы Jackson начал понимать java.time.*, нужно подключить модуль JavaTimeModule.

Подключение (если используешь Maven):

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
</dependency>

Регистрация модуля:

import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;

ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());

Важно: если хочешь сериализовать даты в человекочитаемом формате, отключи запись timestamp:

mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

Пример работы

Event event = new Event("Conference", LocalDateTime.of(2025, 4, 29, 10, 30));
String json = mapper.writeValueAsString(event);
System.out.println(json);

Результат:

{
  "name": "Conference",
  "dateTime": "2025-04-29T10:30:00"
}

Аналогично работает и с другими типами:
LocalDate
LocalTime
ZonedDateTime
Instant

Десериализация обратно

String input = "{\"name\":\"Conference\",\"dateTime\":\"2025-04-29T10:30:00\"}";
Event event = mapper.readValue(input, Event.class);

Другие полезные модули Jackson

ParameterNamesModule — помогает при десериализации через конструкторы без @JsonProperty
Jdk8Module — поддержка Optional, OptionalInt и других типов из java.util
AfterburnerModule — ускоряет работу Jackson на больших объёмах данных

#Java #Training #Medium #Jackson

117 views14:59

Java for Beginner

Jackson

Частичная сериализация с помощью @JsonView

Иногда возникает задача сериализовать один и тот же объект по-разному — в зависимости от ситуации, роли пользователя, уровня доступа или цели запроса. Например, показывать часть полей для публичного API и все — для администратора.

Jackson решает эту задачу с помощью механизма JSON Views.

Что такое JSON Views

@JsonView — это аннотация, позволяющая управлять, какие поля объекта попадут в JSON в зависимости от выбранного представления (view-класса).
Это как "фильтр по уровням доступа", встроенный прямо в сериализацию.

Шаг 1. Определяем уровни видимости (view)

public class Views {
    public static class Public {}
    public static class Internal extends Public {}
}
Можно создавать любые уровни — главное, чтобы они наследовались при необходимости.

Шаг 2. Аннотируем поля модели

import com.fasterxml.jackson.annotation.JsonView;

public class User {
    @JsonView(Views.Public.class)
    private String username;

    @JsonView(Views.Internal.class)
    private String email;

    @JsonView(Views.Internal.class)
    private String role;

    public User() {}

    public User(String username, String email, String role) {
        this.username = username;
        this.email = email;
        this.role = role;
    }

    // Геттеры и сеттеры
}

Теперь:
username виден всем (включая Public)
email и role — только для Internal

Шаг 3. Сериализация с учетом view

ObjectMapper mapper = new ObjectMapper();

User user = new User("alice", "alice@example.com", "ADMIN");

// Публичный вид
String publicJson = mapper
    .writerWithView(Views.Public.class)
    .writeValueAsString(user);

System.out.println(publicJson);

Результат:

{
  "username": "alice"
}

Если сериализовать с Internal view:

String internalJson = mapper
    .writerWithView(Views.Internal.class)
    .writeValueAsString(user);

Результат:

{
  "username": "alice",
  "email": "alice@example.com",
  "role": "ADMIN"
}

Применение в REST (например, Spring)

В Spring можно использовать @JsonView прямо в контроллере:

@GetMapping("/user/public")
@JsonView(Views.Public.class)
public User getPublicUser() {
    return userService.getCurrentUser();
}

@GetMapping("/user/internal")
@JsonView(Views.Internal.class)
public User getInternalUser() {
    return userService.getCurrentUser();
}

Когда это нужно

Публичный/приватный API
Разные роли пользователей (гость, клиент, админ)
Безопасность: не передавать чувствительные поля
Удобство: не создавать множество DTO для каждой ситуации

#Java #Training #Medium #Jackson #JsonView

112 views05:59

Java for Beginner

Jackson

Tree Model и Streaming API в Jackson: когда нужна гибкость и производительность

Jackson предлагает не только стандартную POJO-сериализацию, но и более гибкие модели работы с JSON. Среди них — Tree Model и Streaming API.
Tree Model даёт полную свободу при работе с JSON-структурой, а Streaming API — максимальную производительность при чтении/записи больших файлов.

Tree Model (JsonNode): работа с JSON как с деревом

Иногда структура JSON заранее неизвестна или слишком сложна, чтобы описывать её через Java-классы. В таких случаях удобно использовать дерево узлов — JsonNode.

Пример: чтение JSON как дерева

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

String json = "{ \"user\": { \"name\": \"Alice\", \"age\": 30 } }";

ObjectMapper mapper = new ObjectMapper();
JsonNode rootNode = mapper.readTree(json);

String name = rootNode.path("user").path("name").asText();
int age = rootNode.path("user").path("age").asInt();

System.out.println("Имя: " + name + ", Возраст: " + age);

Tree Model позволяет легко:
— обходить структуру вручную
— проверять наличие полей
— работать с вложенностью и массивами
— модифицировать JSON "на лету"

Когда использовать Tree Model

Когда структура JSON может меняться
Когда нужно читать только часть данных
При разработке универсальных парсеров
Когда сложно заранее описать модель через классы

Streaming API (JsonParser/JsonGenerator)

Для огромных JSON-файлов (например, логов, экспорта из БД) загрузка всего файла в память может быть невозможной. Здесь пригодится стриминговый API — он читает JSON по частям, как поток.

Пример: чтение JSON через JsonParser

import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;

JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser(new File("data.json"));

while (!parser.isClosed()) {
    JsonToken token = parser.nextToken();

    if (JsonToken.FIELD_NAME.equals(token) && "name".equals(parser.getCurrentName())) {
        parser.nextToken();
        System.out.println("Имя: " + parser.getValueAsString());
    }
}
parser.close();

Когда использовать Streaming API

Работа с большими JSON-файлами, которые нельзя загрузить полностью
Требуется максимальная производительность
Необходимо читать JSON "по частям"
Парсинг в системах с ограниченной памятью (например, embedded)

Сравнение подходов

POJO-модель — просто, типобезопасно, но требует классов
Tree Model — гибко, удобно для анализа/модификации
Streaming API — быстро и экономно, но требует ручного контроля

#Java #Training #Medium #Jackson #Tree_Model #Streaming_API

132 views14:59

About

Blog

Apps

Platform