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

// Упрощенная структура из OpenJDK
public class BufferedInputStream extends FilterInputStream {
    // Внутренний буфер в heap JVM
    protected volatile byte[] buf;
    
    // Количество байт, фактически доступных в буфере
    protected int count;
    
    // Текущая позиция чтения в буфере
    protected int pos;
    
    // Позиция маркера для mark/reset, -1 если не установлен
    protected int markpos = -1;
    
    // Максимальное количество байт, читаемых после mark
    protected int marklimit;
    
    // Конструкторы
    public BufferedInputStream(InputStream in) {
        this(in, 8192); // Размер по умолчанию
    }
    
    public BufferedInputStream(InputStream in, int size) {
        super(in);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size]; // Выделение в heap
    }
}

// Упрощенная логика fill()
private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    
    if (markpos < 0) {
        // Маркер не установлен — читаем с начала буфера
        pos = 0;
    } else if (pos >= buffer.length) {
        // Позиция достигла конца буфера
        if (markpos > 0) {
            // Сдвигаем данные от markpos к началу
            int sz = pos - markpos;
            System.arraycopy(buffer, markpos, buffer, 0, sz);
            pos = sz;
            markpos = 0;
        } else if (buffer.length >= marklimit) {
            // Буфер превысил лимит маркера — сбрасываем
            markpos = -1;
            pos = 0;
        } else {
            // Расширяем буфер
            int nsz = pos * 2;
            if (nsz > marklimit) nsz = marklimit;
            byte[] nbuf = new byte[nsz];
            System.arraycopy(buffer, 0, nbuf, 0, pos);
            buf = nbuf;
            buffer = nbuf;
            markpos = 0;
        }
    }
    
    count = pos;
    // Системный вызов: чтение из underlying потока
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0) count = n + pos;
}

try (BufferedInputStream bis = new BufferedInputStream(
        new FileInputStream("data.bin"), 8192)) {
    
    int firstByte = bis.read(); // Инициирует fill()
}

[Java: bis.read()]
  -> [BufferedInputStream: pos=0, count=0, буфер пуст]
    -> [fill()]
      -> [FileInputStream.read(buf, 0, 8192)]
        -> [JNI: нативный readBytes]
          -> [Ядро ОС: syscall read(fd, native_buf, 8192)]
            -> [Page Cache: поиск/загрузка страниц]
            -> [Копирование: 8192 байт из page cache в native_buf]
          -> [Возврат в userspace]
        -> [JNI: копирование 8192 байт в buf[8192] в heap]
      -> [BufferedInputStream: count=8192, pos=0]
    -> [Возврат buf[0] как int]

int secondByte = bis.read(); // pos=1, count=8192, системный вызов отсутствует
int thirdByte = bis.read();  // pos=2, count=8192, системный вызов отсутствует

[Java: bis.read()]
  -> [BufferedInputStream: pos < count? 1 < 8192 — да]
    -> [Возврат buf[1] как int, pos++]

// После 8192 вызовов read()
int byte8193 = bis.read(); // pos=8192, count=8192, буфер пуст

[Java: bis.read()]
  -> [BufferedInputStream: pos < count? 8192 < 8192 — нет]
    -> [fill()]
      -> [System.arraycopy при необходимости]
      -> [FileInputStream.read(buf, 0, 8192)]
        -> [Новый системный вызов]
      -> [count=новое_значение, pos=0]
    -> [Возврат buf[0]]

public void processFile(String path) throws IOException {
    // buf создается в Eden space при конструировании BufferedInputStream
    try (BufferedInputStream bis = new BufferedInputStream(
            new FileInputStream(path))) {
        
        int b;
        // Цикл без аллокаций в heap — GC не вовлечен
        while ((b = bis.read()) != -1) {
            processByte(b);
        }
        
    } // close() вызывается автоматически
      // buf становится недостижимым
      // GC собирает buf и bis при следующей minor collection
}

// Потенциально проблематично: 1MB буфер
BufferedInputStream bis = new BufferedInputStream(fis, 1024 * 1024);

// Антипаттерн: утечка ссылки
private InputStream leakedStream;

public void open(String path) throws IOException {
    leakedStream = new BufferedInputStream(new FileInputStream(path));
    // Если исключение позже — поток не закрыт, buf не освобожден
}

bis.mark(1024); // Запомнить позицию, лимит 1024 байт вперед
// Чтение до 1024 байт
bis.reset();    // Вернуться к отмеченной позиции

// Из fill(): буфер расширяется до marklimit
byte[] nbuf = new byte[nsz]; // Новый массив в heap
System.arraycopy(buffer, 0, nbuf, 0, pos); // Копирование старых данных
buf = nbuf; // Старая ссылка на массив теряется, GC собирает старый buf

public class BufferedPerformanceDemo {
    
    private static final int FILE_SIZE = 10 * 1024 * 1024; // 10 MB
    
    public static void main(String[] args) throws IOException {
        // Создание тестового файла
        createTestFile("test.bin", FILE_SIZE);
        
        // Тест 1: FileInputStream без буферизации
        measure("FileInputStream raw", () -> {
            try (FileInputStream fis = new FileInputStream("test.bin")) {
                while (fis.read() != -1) {} // Побайтово
            }
        });
        
        // Тест 2: FileInputStream с внешним буфером
        measure("FileInputStream + byte[]", () -> {
            try (FileInputStream fis = new FileInputStream("test.bin")) {
                byte[] buf = new byte[8192];
                while (fis.read(buf) != -1) {}
            }
        });
        
        // Тест 3: BufferedInputStream (внутренняя буферизация)
        measure("BufferedInputStream", () -> {
            try (BufferedInputStream bis = new BufferedInputStream(
                    new FileInputStream("test.bin"))) {
                while (bis.read() != -1) {} // Побайтово, но буферизовано
            }
        });
    }
    
    private static void measure(String name, Runnable task) {
        long start = System.nanoTime();
        task.run();
        long ms = (System.nanoTime() - start) / 1_000_000;
        System.out.printf("%s: %d ms%n", name, ms);
    }
    
    private static void createTestFile(String path, int size) throws IOException {
        byte[] data = new byte[size];
        new Random().nextBytes(data);
        try (FileOutputStream fos = new FileOutputStream(path)) {
            fos.write(data);
        }
    }
}

import java.io.*;

public class Task110626 {
    public static void main(String[] args) throws IOException {
        byte[] data = {10, 20, 30, 40, 50};
        BufferedInputStream bis = new BufferedInputStream(new ByteArrayInputStream(data));
        bis.mark(2);
        System.out.print(bis.read());
        System.out.print(bis.read());
        System.out.print(bis.read());
        bis.reset();
        System.out.print(bis.read());
    }
}