public class UnmodifiableView {
    
    public static void main(String[] args) {
        List<String> original = new ArrayList<>(Arrays.asList("A", "B", "C"));
        List<String> unmodifiable = Collections.unmodifiableList(original);
        
        System.out.println("Original: " + original);   // [A, B, C]
        System.out.println("Unmodifiable: " + unmodifiable); // [A, B, C]
        
        // Изменяем исходный список
        original.add("D");
        System.out.println("После изменения оригинала:");
        System.out.println("Original: " + original);   // [A, B, C, D]
        System.out.println("Unmodifiable: " + unmodifiable); // [A, B, C, D] — изменился!
        
        // Попытка изменить view вызовет исключение
        try {
            unmodifiable.add("E"); // UnsupportedOperationException
        } catch (UnsupportedOperationException e) {
            System.err.println("Нельзя изменить view");
        }
        
        //Решение 1: копия + обертка (все равно оригинал может быть изменен, если доступен)
        List<String> copyAndWrap = Collections.unmodifiableList(new ArrayList<>(original));
        original.add("F");
        System.out.println("Copy+wrap не изменился: " + copyAndWrap); // [A, B, C, D] — не изменился
        
        //Решение 2: List.copyOf (Java 10+) — действительно неизменяемый
        List<String> immutable = List.copyOf(original);
        original.add("G");
        System.out.println("List.copyOf: " + immutable); // [A, B, C, D, F] — не изменился
        
        //Решение 3: List.of (Java 9+) — для фиксированного набора значений
        List<String> fixed = List.of("X", "Y", "Z");
        // fixed не зависит от внешних списков
    }
}

import java.util.*;

public class Task030826 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3));
        List<Integer> unmod = Collections.unmodifiableList(list);
        list.add(4);
        try {
            unmod.add(5);
        } catch (UnsupportedOperationException e) {
            System.out.print("ex ");
        }
        System.out.println(unmod.size());
    }
}

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

RFC (Request for Comments) — серия документов Интернет-инженерного совета (IETF), описывающих стандарты, протоколы и технологии Интернета. RFC 8259 является официальной спецификацией формата JSON.

Парсинг — это процесс анализа строки или потока данных в соответствии с правилами формального языка (грамматикой) с целью построения структурированного представления, обычно дерева разбора или абстрактного синтаксического дерева (AST).

REST (Representational State Transfer) — это архитектурный стиль проектирования распределённых систем, введённый Роем Филдингом в его докторской диссертации 2000 года. REST не является протоколом или стандартом в строгом смысле; это набор ограничений и принципов.

Ключевое ограничение — statelessness (отсутствие состояния): каждый запрос от клиента к серверу должен содержать всю информацию, необходимую для его обработки, и сервер не хранит контекст клиента между запросами.

DTD (Document Type Definition) и XSD (XML Schema Definition) — это механизмы определения структуры и допустимых элементов XML-документа. JSON изначально не имел встроенного механизма схем, хотя позже появились JSON Schema и OpenAPI.

{
  "user": {
    "id": 42,
    "name": "Alice",
    "active": true
  }
}

{
  "orders": [
    { "id": 1, "total": 99.99 },
    { "id": 2, "total": 150.00 }
  ]
}

{
  "description": "Line 1\nLine 2\tTabbed",
  "emoji": "\uD83D\uDE00"
}

UTF-8 (Unicode Transformation Format, 8-bit) — это кодировка переменной длины, которая кодирует символы Unicode от 1 до 4 байтами. Символы ASCII (0–127) занимают 1 байт, что делает UTF-8 эффективной для англоязычных текстов.

{
  "integer": 42,
  "negative": -17,
  "float": 3.14159,
  "exponential": 6.022e23,
  "small": 1e-10
}

IEEE 754 — это стандарт представления чисел с плавающей точкой в компьютерах. Double-precision использует 64 бита: 1 бит знака, 11 бит экспоненты и 52 бита мантиссы. Не все десятичные дроби точно представимы в двоичной системе, отсюда ошибки округления.

{
  "enabled": true,
  "debug": false
}

{
  "middleName": null
}

{
  "users": [
    { "id": 1, "name": "Alice" },
    { "id": 2, "name": "Bob" }
  ]
}

Protocol Buffers (protobuf) — бинарный формат сериализации, разработанный Google. В отличие от JSON, protobuf требует предварительного определения схемы (proto-файл), но обеспечивает компактное бинарное представление и строгую типизацию.

JSON Schema — это спецификация (draft 2020-12) для описания структуры JSON-документов. Она позволяет определять типы полей, обязательность, диапазоны значений, регулярные выражения для строк и другие ограничения.

Base64 — это схема кодирования бинарных данных в текстовый формат с использованием 64 символов ASCII (A–Z, a–z, 0–9, +, /). Каждые 3 байта (24 бита) кодируются 4 символами Base64 (по 6 бит каждый), отсюда overhead в 33%.

Bottleneck — это узкое место в системе, которое ограничивает общую производительность. В контексте JSON-парсинга bottleneck часто возникает из-за аллокации объектов в куче и работы GC при обработке больших JSON-документов.

Kernel space и user space — это два режима работы процессора. Kernel space — привилегированный режим, в котором работает код операционной системы и драйверов. User space — непривилегированный режим, в котором работают обычные приложения, включая JVM. Переход между режимами (context switch) — дорогая операция.

Compact strings — оптимизация, введённая в Java 9 (JEP 254). Строки, содержащие только символы Latin-1 (коды 0–255), хранятся в массиве 

 по одному байту на символ. Если встречается символ вне Latin-1, массив переключается на UTF-16 (2 байта на символ).

{
  "users": [
    { "id": 1, "name": "Alice" },
    { "id": 2, "name": "Bob" }
  ]
}

// Потоковый парсинг Jackson — минимум аллокаций
public void processLargeJson(InputStream in) throws IOException {
    // JsonFactory — лёгкий фабричный объект для создания парсеров
    JsonFactory factory = new JsonFactory();
    
    // JsonParser — потоковый парсер, читает JSON без построения дерева
    try (JsonParser parser = factory.createParser(in)) {
        while (parser.nextToken() != JsonToken.END_OBJECT) {
            String fieldName = parser.getCurrentName();
            if ("users".equals(fieldName)) {
                parser.nextToken(); // переходим к массиву
                while (parser.nextToken() == JsonToken.START_OBJECT) {
                    // Обрабатываем каждый объект пользователя
                    int id = 0;
                    String name = null;
                    while (parser.nextToken() != JsonToken.END_OBJECT) {
                        String key = parser.getCurrentName();
                        parser.nextToken();
                        if ("id".equals(key)) {
                            id = parser.getIntValue();
                        } else if ("name".equals(key)) {
                            name = parser.getValueAsString();
                        }
                    }
                    // Обрабатываем пользователя без создания промежуточных объектов
                    processUser(id, name);
                }
            }
        }
    }
}

import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Date;

public class Task040826 {
    static class Event {
        
        public String name;

        public Date date;

        Event(String name, Date date) {
            this.name = name; this.date = date;
        }
    }

    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        Event event = new Event("Party", new Date(0));
        System.out.println(mapper.writeValueAsString(event));
    }
}

import java.util.*;

public class NullInCollections {
    
    public static void main(String[] args) {
        //Антипаттерн: Set.of() с null
        try {
            Set<String> set = Set.of("a", null, "b"); // NullPointerException
        } catch (NullPointerException e) {
            System.err.println("Set.of() не допускает null");
        }
        
        //Map.of() с null ключом или значением
        try {
            Map<String, String> map = Map.of("key", null); // NullPointerException
        } catch (NullPointerException e) {
            System.err.println("Map.of() не допускает null-значений");
        }
        
        //Решение: использовать HashMap для поддержки null
        Map<String, String> hashMap = new HashMap<>();
        hashMap.put("key1", "value1");
        hashMap.put("key2", null); // допустимо
        hashMap.put(null, "value3"); // допустим null-ключ
        System.out.println("HashMap with nulls: " + hashMap);
        
        //Если нужна неизменяемость с null, используйте unmodifiable обертку
        Map<String, String> unmodifiableWithNull = Collections.unmodifiableMap(hashMap);
        // unmodifiableWithNull нельзя изменить, но null сохраняются
        System.out.println("Unmodifiable with null: " + unmodifiableWithNull);
        // Однако это не иммутабельная коллекция — исходный hashMap можно изменить, и view отразит
        
        //Для безопасной работы с неизменяемыми коллекциями и null — избегайте null
        // Используйте Optional или значения-заглушки
        Map<String, Optional<String>> safeMap = Map.of(
            "key1", Optional.of("value"),
            "key2", Optional.empty() // представляет null
        );
        // При чтении: safeMap.get("key2").orElse("default");
        
        //Использование checkedMap для типизированной проверки (не решает проблему null)
        Map<String, String> checked = Collections.checkedMap(
            new HashMap<>(), String.class, String.class);
        checked.put("a", null); // допустимо, проверка типов не касается null
    }
}

import java.util.Map;

public class Task050826 {
    public static void main(String[] args) {
        try {
            Map<String, String> map = Map.of(
                "key1", "value1",
                "key2", null
            );
            System.out.println("size=" + map.size());
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName());
        }
    }
}