import java.io.*;

public class NativeSerializationExample {
    
    // Serializable — маркерный интерфейс, указывающий JVM, что класс может быть сериализован
    public static class User implements Serializable {
        // serialVersionUID — контрольная сумма версии класса для проверки совместимости
        private static final long serialVersionUID = 1L;
        
        private String name;
        private int age;
        private transient String password;  // transient — поле не сериализуется
        
        public User(String name, int age, String password) {
            this.name = name;
            this.age = age;
            this.password = password;
        }
        
        @Override
        public String toString() {
            return "User{name='" + name + "', age=" + age + ", password='" + password + "'}";
        }
    }
    
    public byte[] serialize(User user) throws IOException {
        // ByteArrayOutputStream — поток, который пишет байты в массив в памяти
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            
            // writeObject обходит граф объектов и записывает его в поток
            oos.writeObject(user);
            oos.flush();
            
            // toByteArray возвращает скопированный массив байтов
            return baos.toByteArray();
        }
    }
    
    public User deserialize(byte[] data) throws IOException, ClassNotFoundException {
        try (ByteArrayInputStream bais = new ByteArrayInputStream(data);
             ObjectInputStream ois = new ObjectInputStream(bais)) {
            
            // readObject восстанавливает граф объектов из байтов
            return (User) ois.readObject();
        }
    }
}

public class DeserializationFlow {
    
    // При десериализации конструктор НЕ вызывается
    // Вместо этого JVM использует механизм sun.misc.Unsafe.allocateInstance()
    // или аналогичный внутренний API для создания "сырого" объекта
    
    public void demonstrate(Path file) throws Exception {
        try (ObjectInputStream ois = new ObjectInputStream(
                new BufferedInputStream(Files.newInputStream(file)))) {
            
            Object obj = ois.readObject();
            
            // Если класс реализует readObject(), он вызывается после заполнения полей
            // Это позволяет выполнить пост-инициализацию: восстановить transient-поля,
            // проверить инварианты, зарегистрировать слушателей
        }
    }
}

public class SessionPersistence {
    
    public static class AppState implements Serializable {
        private static final long serialVersionUID = 1L;
        private List<Document> openDocuments;
        private Map<String, UserPreference> preferences;
        private transient Connection dbConnection;  // соединение не сохраняем
    }
    
    public void saveState(AppState state, Path file) throws IOException {
        // Atomic write: сначала пишем во временный файл, потом атомарно перемещаем
        Path temp = Files.createTempFile(file.getParent(), "state_", ".tmp");
        try (ObjectOutputStream oos = new ObjectOutputStream(
                new BufferedOutputStream(Files.newOutputStream(temp)))) {
            oos.writeObject(state);
        }
        Files.move(temp, file, StandardCopyOption.REPLACE_EXISTING,
                   StandardCopyOption.ATOMIC_MOVE);
    }
    
    public AppState loadState(Path file) throws IOException, ClassNotFoundException {
        try (ObjectInputStream ois = new ObjectInputStream(
                new BufferedInputStream(Files.newInputStream(file)))) {
            AppState state = (AppState) ois.readObject();
            // Восстанавливаем transient-поля
            state.dbConnection = createNewConnection();
            return state;
        }
    }
    
    private Connection createNewConnection() {
        // Логика создания соединения
        return null;
    }
}

// Интерфейс удалённого сервиса
public interface OrderService extends Remote {
    Order createOrder(OrderRequest request) throws RemoteException;
}

// Реализация на сервере
public class OrderServiceImpl extends UnicastRemoteObject implements OrderService {
    public Order createOrder(OrderRequest request) {
        // OrderRequest сериализуется при передаче от клиента к серверу
        // Order сериализуется при возврате от сервера к клиенту
        return new Order(/* ... */);
    }
}

public class CacheManager {
    
    private final Map<String, byte[]> localCache = new ConcurrentHashMap<>();
    
    public void put(String key, Serializable value) throws IOException {
        byte[] bytes = serialize(value);
        localCache.put(key, bytes);
    }
    
    public <T> T get(String key, Class<T> type) 
            throws IOException, ClassNotFoundException {
        byte[] bytes = localCache.get(key);
        if (bytes == null) return null;
        return type.cast(deserialize(bytes));
    }
    
    private byte[] serialize(Serializable obj) throws IOException {
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(obj);
            return baos.toByteArray();
        }
    }
    
    private Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
        try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
             ObjectInputStream ois = new ObjectInputStream(bais)) {
            return ois.readObject();
        }
    }
}

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