import java.util.*;

public class Task050525 {
    public static void main(String[] args) {
        TreeMap<String, Integer> tree = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
        tree.put("Apple", 1);
        tree.put("banana", 2);
        tree.put("APPLE", 3);
        
        System.out.println(tree.size() + " " + tree.get("aPpLe"));
    }
}

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;
    }
}

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

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();
    }
}

{
  "product_name": "laptop"
}

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

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;
    }
}

{ "user_name": "admin" }

{ "login": "admin" }

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

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.

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

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

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

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}
]

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

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

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

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);

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

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

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

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

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);

{
  "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;

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

import java.util.*;

public class Task060525 {
    public static void main(String[] args) {
        TreeSet<String> tree = new TreeSet<>(Comparator.reverseOrder());
        tree.add("B");
        tree.add("A");
        tree.add("C");
        tree.add("A"); 
        
        System.out.println(tree.pollFirst() + " " + tree.pollLast());
    }
}

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();
    }
}

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

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

    private int age;

    public User() {}

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

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

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

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

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

import com.fasterxml.jackson.databind.ObjectMapper;

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

import com.fasterxml.jackson.databind.DeserializationFeature;

mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

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

import com.fasterxml.jackson.databind.SerializationFeature;

mapper.enable(SerializationFeature.INDENT_OUTPUT);

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

import com.fasterxml.jackson.annotation.JsonInclude;

mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);

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

{
  "name": "Alice"
}

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

mapper.configure(SerializationFeature.WRITE_NUMBERS_AS_STRINGS, true);

{
  "age": "30"
}

import java.text.SimpleDateFormat;

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

import java.util.*;

public class Task070525 {
    public static void main(String[] args) {
        TreeMap<Integer, String> tree = new TreeMap<>();
        tree.put(1, "Java");
        tree.put(1, "Python");
        tree.put(2, "C++");
        tree.put(3, "Go");
        tree.remove(2);
        
        System.out.println(tree.subMap(1, true, 3, true).values());
    }
}