// Jackson — самая популярная библиотека для JSON в Java
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonExample {
    private static final ObjectMapper mapper = new ObjectMapper();
    
    public String toJson(User user) throws JsonProcessingException {
        return mapper.writeValueAsString(user);
    }
    
    public User fromJson(String json) throws JsonProcessingException {
        return mapper.readValue(json, User.class);
    }
}

// user.proto
syntax = "proto3";
message User {
    string name = 1;
    int32 age = 2;
    string email = 3;
}

// Сгенерированный Java-код из .proto
User user = User.newBuilder()
    .setName("Alice")
    .setAge(30)
    .setEmail("alice@example.com")
    .build();

byte[] bytes = user.toByteArray();
User parsed = User.parseFrom(bytes);

import com.esotericsoftware.kryo.Kryo;
import com.esotericsoftware.kryo.io.Input;
import com.esotericsoftware.kryo.io.Output;

public class KryoExample {
    private final Kryo kryo = new Kryo();
    
    public byte[] serialize(Object obj) {
        Output output = new Output(1024, -1);
        kryo.writeClassAndObject(output, obj);
        return output.toBytes();
    }
    
    public Object deserialize(byte[] bytes) {
        Input input = new Input(bytes);
        return kryo.readClassAndObject(input);
    }
}

// JEP 290: фильтрация десериализации с Java 9
public void safeDeserialize(InputStream in) throws IOException, ClassNotFoundException {
    ObjectInputStream ois = new ObjectInputStream(in);
    
    // Разрешаем десериализовать только классы из доверенных пакетов
    ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(
        "maxdepth=5;maxrefs=10000;com.myapp.*;!*"
    );
    ois.setObjectInputFilter(filter);
    
    Object obj = ois.readObject();
}

public class PooledSerializer {
    private final ByteArrayOutputStream baos = new ByteArrayOutputStream(8192);
    private final ObjectOutputStream oos;
    
    public PooledSerializer() throws IOException {
        this.oos = new ObjectOutputStream(baos);
    }
    
    public synchronized byte[] serialize(Object obj) throws IOException {
        baos.reset();  // сбрасываем буфер, не создавая новый
        oos.reset();   // сбрасываем таблицу handles
        oos.writeObject(obj);
        oos.flush();
        return baos.toByteArray();  // копирует текущий буфер
    }
}

import java.io.*;

public class Task290726 {
    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        MyObject290726 obj = new MyObject290726("Hello");
        oos.writeObject(obj);
        oos.close();

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bais);
        MyObject290726 deserialized = (MyObject290726) ois.readObject();
        ois.close();

        System.out.println(deserialized.value);
    }

    static class MyObject290726 implements Serializable {
        transient String value;
        MyObject290726(String value) { this.value = value; }
    }
}

import java.util.Arrays;

public class ArraysCopyOfExample {
    
    public static void main(String[] args) {
        int[] original = {1, 2, 3};
        
        //Копирование с увеличением длины
        int[] expanded = Arrays.copyOf(original, 5);
        System.out.println("Expanded: " + Arrays.toString(expanded)); // [1, 2, 3, 0, 0]
        System.out.println("Original unchanged: " + Arrays.toString(original)); // [1, 2, 3]
        
        //Копирование с уменьшением длины
        int[] truncated = Arrays.copyOf(original, 2);
        System.out.println("Truncated: " + Arrays.toString(truncated)); // [1, 2]
        
        //Для объектов — копируются ссылки
        class Person { String name; Person(String n) { name = n; } }
        Person[] people = {new Person("Alice"), new Person("Bob")};
        Person[] copy = Arrays.copyOf(people, 3);
        copy[0].name = "Charlie"; // изменяем объект через копию
        System.out.println("Original[0].name: " + people[0].name); // Charlie — изменилось!
        // Это поверхностное копирование, объекты общие
        
        //Присвоение результата обратно для замены массива
        int[] numbers = {10, 20, 30};
        numbers = Arrays.copyOf(numbers, numbers.length + 1);
        numbers[3] = 40;
        System.out.println("After reassign: " + Arrays.toString(numbers)); // [10, 20, 30, 40]
    }
}

import java.util.Arrays;

public class Task300726 {
    static class Item300726 {
        int value;
        Item300726(int v) { value = v; }
    }

    public static void main(String[] args) {
        Item300726[] original = {new Item300726(1), new Item300726(2)};
        Item300726[] copy = Arrays.copyOf(original, 2);
        copy[0].value = 10;
        copy[1] = new Item300726(20);
        System.out.println(original[0].value);
        System.out.println(original[1].value);
    }
}

import java.io.Serializable;

public class Document implements Serializable {
    // Маркерный интерфейс не требует методов
    private String title;
    private String content;
}

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

public class Container implements Serializable {
    private Document doc;  // Document должен быть Serializable
    private Metadata meta; // Metadata тоже должен быть Serializable
}

public class Library implements Serializable {
    private String name;
    private List<Book> books;  // Book тоже должен быть Serializable
    private Librarian head;    // Librarian тоже должен быть Serializable
}

Глубокая копия (deep copy) — это копия объекта, при которой копируются не только сам объект, но и все объекты, на которые он ссылается, рекурсивно. В отличие от поверхностной копии (shallow copy), где копируются только ссылки на те же внутренние объекты.

public class Config implements Serializable {
    private static String globalPrefix = "app";  // не сериализуется
    private String instanceName;                  // сериализуется
}

public class UserSession implements Serializable {
    private String username;
    private transient String password;      // не сериализуется
    private transient Connection dbConn;    // не сериализуется
    private transient byte[] cachedToken;   // не сериализуется
}

public class Base {  // не Serializable
    private int baseField;
    public Base() {}  // обязателен no-arg конструктор
}

public class Derived extends Base implements Serializable {
    private int derivedField;  // только это поле сериализуется
}

No-arg конструктор (no-argument constructor, default constructor) — это конструктор без параметров. В Java, если класс не объявляет явных конструкторов, компилятор генерирует no-arg конструктор автоматически. Если объявлен хотя бы один конструктор с параметрами, no-arg конструктор нужно объявлять явно.

public class Node implements Serializable {
    private String name;
    private Node next;  // может образовать цикл
}

// Создаём цикл: A -> B -> C -> A
Node a = new Node("A");
Node b = new Node("B");
Node c = new Node("C");
a.next = b;
b.next = c;
c.next = a;  // цикл!

// Сериализация не зацикливается благодаря таблице handles
oos.writeObject(a);  // записывает A, B, C, затем backreference на A

public class Document implements Serializable {
    private static final long serialVersionUID = 1L;
    private String title;
}

SHA (Secure Hash Algorithm) — семейство криптографических хеш-функций, которые преобразуют входные данные произвольной длины в строку фиксированной длины (дайджест). В контексте serialVersionUID используется не криптографический SHA, а похожий алгоритм хеширования структурных элементов класса.

// Версия 1
public class User implements Serializable {
    private String name;
    private int age;
}

// Версия 2 — добавлен метод, serialVersionUID изменился!
public class User implements Serializable {
    private String name;
    private int age;
    
    public void greet() {  // новый метод изменяет вычисленный UID
        System.out.println("Hello");
    }
}

java.io.InvalidClassException: User; local class incompatible:
stream classdesc serialVersionUID = -123456789, 
local class serialVersionUID = 987654321

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
}

// Версия 1
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
}

// Версия 2 — совместимое изменение: добавлено поле
public class User implements Serializable {
    private static final long serialVersionUID = 1L;  // тот же UID!
    private String name;
    private String email;  // новое поле, старые объекты получат null
}

private void writeObject(ObjectOutputStream out) throws IOException;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;

public class SecureDocument implements Serializable {
    private static final long serialVersionUID = 1L;
    private String title;
    private transient String secretContent;  // не сериализуем напрямую
    
    private void writeObject(ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();  // записываем title и другие нетранзиентные поля
        // Шифруем секретный контент перед записью
        String encrypted = encrypt(secretContent);
        out.writeUTF(encrypted);
    }
    
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();  // читаем title
        // Дешифруем секретный контент
        String encrypted = in.readUTF();
        this.secretContent = decrypt(encrypted);
    }
    
    private String encrypt(String data) { /* ... */ return data; }
    private String decrypt(String data) { /* ... */ return data; }
}

Singleton — это порождающий паттерн проектирования, гарантирующий, что класс имеет только один экземпляр, и предоставляющий глобальную точку доступа к нему. При десериализации singleton механизм создаёт новый объект, нарушая гарантию единственности. readResolve возвращает существующий экземпляр.

public class Singleton implements Serializable {
    private static final long serialVersionUID = 1L;
    private static final Singleton INSTANCE = new Singleton();
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        return INSTANCE;
    }
    
    // При десериализации возвращаем существующий INSTANCE, а не новый объект
    private Object readResolve() {
        return INSTANCE;
    }
}

Прокси-сериализация (serialization proxy pattern) — это паттерн, при котором вместо самого объекта сериализуется лёгкий прокси-объект (proxy), содержащий только необходимые данные, а при десериализации прокси через readResolve восстанавливает оригинальный объект через его конструктор или фабрику. Это защищает инварианты, предотвращает создание "сырых" объектов и позволяет менять внутреннюю структуру класса, не ломая совместимость.

public class ComplexObject implements Serializable {
    private static final long serialVersionUID = 1L;
    private final int x;
    private final int y;
    // инвариант: x >= 0 && y >= 0
    
    public ComplexObject(int x, int y) {
        if (x < 0 || y < 0) throw new IllegalArgumentException();
        this.x = x;
        this.y = y;
    }
    
    // Вместо себя сериализуем прокси
    private Object writeReplace() {
        return new SerializationProxy(x, y);
    }
    
    // Запрещаем десериализацию ComplexObject напрямую
    private void readObject(ObjectInputStream in) throws InvalidObjectException {
        throw new InvalidObjectException("Proxy required");
    }
    
    private static class SerializationProxy implements Serializable {
        private static final long serialVersionUID = 1L;
        private final int x;
        private final int y;
        
        SerializationProxy(int x, int y) {
            this.x = x;
            this.y = y;
        }
        
        // При десериализации прокси восстанавливаем ComplexObject через конструктор
        private Object readResolve() {
            return new ComplexObject(x, y);  // инвариант проверяется!
        }
    }
}

import java.io.*;

public class Task310726 {
    static class DataV1 implements Serializable {
        private static final long serialVersionUID = 1L;
        String name = "John";
    }

    static class DataV2 implements Serializable {
        private static final long serialVersionUID = 1L;
        String fullName;
    }

    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(new DataV1());
        }

        byte[] bytes = baos.toByteArray();
        try (ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
            DataV2 obj = (DataV2) ois.readObject();
            System.out.println(obj.fullName);
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName());
        }
    }
}