public class CloneVsCopy {
    
    //Проблемный clone
    static class PersonBad implements Cloneable {
        String name;
        List<String> hobbies;
        
        PersonBad(String name, List<String> hobbies) {
            this.name = name;
            this.hobbies = new ArrayList<>(hobbies);
        }
        
        @Override
        public PersonBad clone() {
            try {
                PersonBad cloned = (PersonBad) super.clone(); // shallow copy!
                // hobbies все еще ссылается на тот же список
                return cloned;
            } catch (CloneNotSupportedException e) {
                throw new AssertionError();
            }
        }
    }
    
    //Копирующий конструктор
    static class PersonGood {
        final String name;
        final List<String> hobbies;
        
        PersonGood(String name, List<String> hobbies) {
            this.name = name;
            this.hobbies = new ArrayList<>(hobbies);
        }
        
        // Копирующий конструктор
        PersonGood(PersonGood other) {
            this.name = other.name;
            this.hobbies = new ArrayList<>(other.hobbies); // глубокое копирование
        }
        
        // Статическая фабрика
        static PersonGood copyOf(PersonGood other) {
            return new PersonGood(other);
        }
        
        PersonGood withName(String name) {
            return new PersonGood(name, this.hobbies);
        }
    }
    
    //Record (Java 16+) — идеален для immutable данных
    record PersonRecord(String name, List<String> hobbies) {
        PersonRecord {
            // Защитное копирование в компактном конструкторе
            hobbies = List.copyOf(hobbies);
        }
        
        // Record автоматически предоставляет конструктор копирования
    }
}

public class Task080626 {
    static class Data implements Cloneable {
        int[] values = {1, 2, 3};

        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Data original = new Data();
        Data cloned = (Data) original.clone();
        cloned.values[0] = 100;

        System.out.println(original.values[0]);
        System.out.println(cloned.values[0]);
    }
}

public class ByteByByteCopy {
    
    public static void copyByteByByte(String source, String dest) throws IOException {
        long start = System.nanoTime();
        int totalBytes = 0;
        
        try (FileInputStream fis = new FileInputStream(source);
             FileOutputStream fos = new FileOutputStream(dest)) {
            
            int byteValue;
            // Каждая итерация = полный цикл системного вызова
            while ((byteValue = fis.read()) != -1) {
                fos.write(byteValue); // Еще один системный вызов на запись
                totalBytes++;
            }
        }
        
        long duration = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("Copied %d bytes in %d ms (byte-by-byte)%n", totalBytes, duration);
    }
    
    public static void main(String[] args) throws IOException {
        // Создание тестового файла 1 MB
        byte[] oneMB = new byte[1024 * 1024];
        new Random().nextBytes(oneMB);
        try (FileOutputStream fos = new FileOutputStream("source.bin")) {
            fos.write(oneMB);
        }
        
        // Побайтовое копирование
        copyByteByByte("source.bin", "dest_byte_by_byte.bin");
    }
}

Поток выполнения:
  [Java-код: read()]
    -> [JVM: нативный метод read0()]
      -> [JNI: переход в нативный код]
        -> [Ядро ОС: syscall read(fd, buf, 1)]
          -> [Page Cache: поиск страницы 4KB]
            -> [При промахе: чтение с диска в page cache]
          -> [Копирование: 1 байт из page cache в нативный буфер]
        -> [Возврат в userspace]
      -> [JNI: копирование 1 байта в heap]
    -> [Java: возврат int]

public class BufferedCopy {
    
    public static void copyWithBuffer(String source, String dest, int bufferSize) 
            throws IOException {
        long start = System.nanoTime();
        int totalBytes = 0;
        
        // Буфер создается в heap Eden space
        // Для bufferSize = 4096: 4KB массив, быстро собирается GC если не переиспользуется
        byte[] buffer = new byte[bufferSize];
        
        try (FileInputStream fis = new FileInputStream(source);
             FileOutputStream fos = new FileOutputStream(dest)) {
            
            int bytesRead;
            // Каждая итерация = один системный вызов на чтение блока
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead); // Один системный вызов на запись блока
                totalBytes += bytesRead;
            }
        }
        
        long duration = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("Copied %d bytes in %d ms (buffer=%d bytes)%n", 
            totalBytes, duration, bufferSize);
    }
    
    public static void main(String[] args) throws IOException {
        // Тест с разными размерами буфера
        int[] sizes = {128, 512, 1024, 4096, 8192, 65536};
        for (int size : sizes) {
            copyWithBuffer("source.bin", "dest_" + size + ".bin", size);
        }
    }
}

Первая итерация read(buffer[4096]):
  [Java-код: read(buffer)]
    -> [JVM: нативный метод readBytes()]
      -> [JNI: переход в нативный код]
        -> [Ядро ОС: syscall read(fd, buf, 4096)]
          -> [Page Cache: поиск страниц, загрузка при необходимости]
          -> [Копирование: 4096 байт из page cache в нативный буфер]
        -> [Возврат в userspace]
      -> [JNI: копирование 4096 байт в buffer[4096] в heap]
    -> [Java: возврат 4096]

Вторая итерация read(buffer[4096]):
  [Java-код: read(buffer)]
    -> [JVM: нативный метод readBytes()]
      -> [JNI: переход в нативный код]
        -> [Ядро ОС: syscall read(fd, buf, 4096)]
          -> [Page Cache: страницы уже в кэше]
          -> [Копирование: 4096 байт]
        -> [Возврат]
      -> [JNI: копирование 4096 байт в buffer в heap]
    -> [Java: возврат 4096]

// Всего 256 итераций для 1 MB вместо 1 048 576

// Антипаттерн: создание буфера внутри цикла
for (String file : files) {
    byte[] buffer = new byte[8192]; // Создание при каждой итерации
    copyFile(file, buffer);
    // buffer становится мусором, GC собирает его
}

// Паттерн: переиспользование буфера
byte[] buffer = new byte[8192]; // Один буфер на все итерации
for (String file : files) {
    copyFile(file, buffer); // Передача по ссылке, без создания
}
// Буфер живет до выхода из метода, собирается одним GC

public class ThreadLocalBuffer {
    // Каждый поток получает свой буфер 8KB
    private static final ThreadLocal<byte[]> BUFFER = 
        ThreadLocal.withInitial(() -> new byte[8192]);
    
    public void copyFileThreadSafe(String source, String dest) throws IOException {
        byte[] buffer = BUFFER.get(); // Буфер потока, без синхронизации
        
        try (FileInputStream fis = new FileInputStream(source);
             FileOutputStream fos = new FileOutputStream(dest)) {
            int bytesRead;
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }
        }
        // Буфер остается в ThreadLocal, не собирается GC между вызовами
    }
}

// Потенциально проблематично: 1MB буфер как humongous object
byte[] largeBuffer = new byte[1024 * 1024];

// Предпочтительнее: несколько итераций с 8KB буфером
byte[] smallBuffer = new byte[8192];
for (int i = 0; i < 128; i++) { // 128 * 8KB = 1MB
    fis.read(smallBuffer);
    // Обработка
}

// Внутреннее устройство BufferedInputStream
public class BufferedInputStream extends FilterInputStream {
    protected volatile byte[] buf; // Буфер в heap
    protected int count;           // Количество доступных байт
    protected int pos;             // Текущая позиция чтения
    protected int markpos = -1;    // Позиция маркера
    
    // Конструктор по умолчанию: buf = new byte[8192]
    public BufferedInputStream(InputStream in) {
        this(in, 8192);
    }
}

// Использование: прозрачная буферизация
try (BufferedInputStream bis = new BufferedInputStream(
        new FileInputStream("source.bin"))) {
    
    int byteValue;
    // Чтение выглядит побайтовым, но фактически буферизовано
    while ((byteValue = bis.read()) != -1) {
        processByte(byteValue);
    }
}

import java.io.*;

public class Task090626 {
    public static void main(String[] args) throws IOException {
        PrintWriter pw = new PrintWriter("out.txt");
        pw.print("Hello");
        try (BufferedReader br = new BufferedReader(new FileReader("out.txt"))) {
            System.out.println(br.readLine());
        }
    }
}

public class FinalizeVsCleaner {
    
    //Антипаттерн: finalize (deprecated)
    @Deprecated
    static class BadResource {
        private final FileInputStream stream;
        
        BadResource(String path) throws IOException {
            this.stream = new FileInputStream(path);
        }
        
        @Override
        protected void finalize() throws Throwable {
            stream.close(); // Неизвестно, когда и будет ли вызвано!
        }
    }
    
    //Решение: AutoCloseable + try-with-resources
    static class GoodResource implements AutoCloseable {
        private final FileInputStream stream;
        
        GoodResource(String path) throws IOException {
            this.stream = new FileInputStream(path);
        }
        
        public void doWork() { /* ... */ }
        
        @Override
        public void close() throws IOException {
            if (stream != null) stream.close();
        }
    }
    
    // Cleaner для критических native-ресурсов (Java 9+)
    static class NativeResource implements AutoCloseable {
        private final Cleaner cleaner = Cleaner.create();
        private final Cleaner.Cleanable cleanable;
        private final long nativeHandle;
        
        NativeResource(long handle) {
            this.nativeHandle = handle;
            this.cleanable = cleaner.register(this, new CleanupAction(handle));
        }
        
        private static class CleanupAction implements Runnable {
            private final long handle;
            CleanupAction(long handle) { this.handle = handle; }
            @Override
            public void run() {
                freeNativeMemory(handle); // native-функция
            }
        }
        
        @Override
        public void close() {
            cleanable.clean(); // явный вызов
        }
        
        private static native void freeNativeMemory(long handle);
    }
}

public class Task100626 {
    static class Resource implements AutoCloseable {
        
        @Override
        public void close() {
            throw new RuntimeException("Close exception");
        }
    }

    public static void main(String[] args) {
        
        try (Resource r = new Resource()) {
            
            throw new IllegalArgumentException("Try exception");
            
        } catch (Exception e) {
            
            System.out.println(e.getClass().getSimpleName());
            Throwable[] suppressed = e.getSuppressed();
            
            if (suppressed.length > 0) {
                System.out.println(suppressed[0].getClass().getSimpleName());
            }
        }
    }
}