import java.nio.channels.SeekableByteChannel;
import java.nio.file.*;
import java.nio.*;

public class Task270726 {
    public static void main(String[] args) throws Exception {
        Path path = Paths.get("test.txt");
        try (SeekableByteChannel ch = Files.newByteChannel(path,
                StandardOpenOption.CREATE, StandardOpenOption.WRITE, StandardOpenOption.READ)) {
            ch.write(ByteBuffer.wrap("Hello".getBytes())); 
            ch.position(10);                
            ch.write(ByteBuffer.wrap("World".getBytes())); 
            System.out.println(ch.size());
        }
    }
}

import java.util.Arrays;

public class ArrayCopyPerformance {
    
    public static void main(String[] args) {
        int[] src = new int[1000000];
        for (int i = 0; i < src.length; i++) src[i] = i;
        
        //Медленно: ручной цикл
        int[] dest1 = new int[src.length];
        for (int i = 0; i < src.length; i++) {
            dest1[i] = src[i];
        }
        
        //Быстро: System.arraycopy
        int[] dest2 = new int[src.length];
        System.arraycopy(src, 0, dest2, 0, src.length);
        
        //Удобно: Arrays.copyOf (использует arraycopy внутри)
        int[] dest3 = Arrays.copyOf(src, src.length);
        
        // Частичное копирование
        int[] destPartial = new int[100];
        System.arraycopy(src, 500, destPartial, 0, 100); // копируем 100 элементов с позиции 500
        
        // Опасность с объектами
        String[] strings = {"a", "b", "c"};
        Object[] objects = new Object[3];
        System.arraycopy(strings, 0, objects, 0, 3); // OK: String[] -> Object[]
        
        try {
            // Ошибка: несовместимые типы
            Integer[] ints = {1, 2, 3};
            System.arraycopy(ints, 0, strings, 0, 3); // ArrayStoreException
        } catch (ArrayStoreException e) {
            System.err.println("Типы несовместимы: " + e);
        }
        
        // Для примитивов проверка осуществляется во время выполнения
        // но совместимость гарантируется компилятором, если типы одинаковы
    }
}

public class Task280726 {
    public static void main(String[] args) {
        Object[] src = {"A", "B", 1};
        String[] dest = new String[3];
        System.arraycopy(src, 0, dest, 0, 3);
        System.out.println(dest[0]);
    }
}

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