// Упрощенная структура из OpenJDK
public class BufferedOutputStream extends FilterOutputStream {
    // Внутренний буфер в heap JVM
    protected byte[] buf;
    
    // Количество байт, фактически записанных в буфер
    protected int count;
    
    // Конструкторы
    public BufferedOutputStream(OutputStream out) {
        this(out, 8192); // Размер по умолчанию
    }
    
    public BufferedOutputStream(OutputStream out, int size) {
        super(out);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size]; // Выделение в heap
    }
}

public void write(int b) throws IOException {
    if (count >= buf.length) {
        flushBuffer(); // Буфер полон — сброс
    }
    buf[count++] = (byte) b; // Запись в heap, системный вызов отсутствует
}

[Java: bos.write(65)]
  -> [BufferedOutputStream: count < buf.length?]
    -> [buf[count++] = 65] // Прямая запись в массив heap
    -> [Возврат]

private void flushBuffer() throws IOException {
    if (count > 0) {
        // Системный вызов: запись накопленных данных
        out.write(buf, 0, count); // out — underlying FileOutputStream
        count = 0; // Сброс счетчика
    }
}

[Java: flushBuffer()]
  -> [FileOutputStream.write(buf, 0, count)]
    -> [JNI: нативный writeBytes]
      -> [Ядро ОС: syscall write(fd, native_buf, count)]
        -> [Page Cache: копирование в dirty pages]
        -> [Пометка страниц как dirty]
      -> [Возврат в userspace]
    -> [Возврат в Java]
  -> [count = 0]

public void flush() throws IOException {
    flushBuffer();      // Сброс buf в FileOutputStream
    out.flush();        // Проксирование вниз по цепочке
}

// Пример: гарантия доставки для критичных данных
try (BufferedOutputStream bos = new BufferedOutputStream(
        new FileOutputStream("critical.dat"))) {
    
    bos.write(transactionData);
    bos.flush(); // Сброс в page cache
    
    // Для финансовых данных — fsync
    bos.out.getFD().sync(); // Физическая запись на диск
}

try (BufferedOutputStream bos = new BufferedOutputStream(
        new FileOutputStream("output.bin"), 8192)) {
    
    for (int i = 0; i < 10000; i++) {
        bos.write(i); // Накопление в buf, системные вызовы отсутствуют
    }
    // После цикла: count=10000, buf содержит данные в heap
}

[Java: bos.write(byte_8192)]
  -> [count >= 8192? да]
    -> [flushBuffer()]
      -> [FileOutputStream.write(buf, 0, 8192)]
        -> [syscall write: 8192 байт в page cache]
      -> [count = 0]
    -> [buf[0] = byte_8192]
    -> [count = 1]

} // try-with-resources вызывает close()

public void close() throws IOException {
    try (OutputStream os = out) {
        flush(); // Неявный flush перед закрытием
    } // out.close() вызывается автоматически
}

public void writeRecords(String path, List<Record> records) throws IOException {
    // buf создается в Eden space
    try (BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(path))) {
        
        for (Record record : records) {
            byte[] data = record.toBytes(); // Новый массив при каждой итерации!
            bos.write(data); // Копирование в buf или flushBuffer()
            // data становится мусором
        }
        
        bos.flush(); // Явный сброс остатка
        
    } // close() с неявным flush()
    
    // buf и все data[] собираются GC
}

public void writeRecordsOptimized(String path, List<Record> records) throws IOException {
    // Переиспользуемый буфер для сериализации
    ByteArrayOutputStream baos = new ByteArrayOutputStream(1024);
    
    try (BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(path))) {
        
        for (Record record : records) {
            baos.reset(); // Сброс без создания нового объекта
            
            record.serialize(baos); // Запись в переиспользуемый baos
            
            byte[] data = baos.toByteArray(); // Все еще создается массив
            // Лучше: запись напрямую в bos, минуя baos
        }
    }
}

public void writeRecordsDirect(String path, List<Record> records) throws IOException {
    try (DataOutputStream dos = new DataOutputStream(
            new BufferedOutputStream(new FileOutputStream(path)))) {
        
        for (Record record : records) {
            dos.writeUTF(record.getId());      // Прямая запись в buf
            dos.writeLong(record.getTimestamp()); // Без промежуточных массивов
            dos.writeInt(record.getValue());
            // Данные накапливаются в buf BufferedOutputStream
        }
        
    } // Автоматический flush() и close()
}

// Антипаттерн: данные могут не попасть в файл
public void dangerousWrite(String path, String data) throws IOException {
    BufferedOutputStream bos = new BufferedOutputStream(
        new FileOutputStream(path));
    bos.write(data.getBytes());
    // flush() не вызван!
    // close() не вызван!
    // При выходе из метода: buf содержит данные, но не сброшен
    // GC финализирует объект, close() вызовется через Cleaner, но с задержкой
}

// Правильно: гарантированный flush и close
public void safeWrite(String path, String data) throws IOException {
    try (BufferedOutputStream bos = new BufferedOutputStream(
            new FileOutputStream(path))) {
        bos.write(data.getBytes());
        // flush() вызовется неявно в close()
    }
}

public class BufferedFileCopy {
    
    private static final int BUFFER_SIZE = 8192;
    
    public static void copy(String sourcePath, String destPath) throws IOException {
        // Буфер для чтения — внешний, создается в heap
        byte[] buffer = new byte[BUFFER_SIZE];
        
        // BufferedInputStream: buf[8192] в heap для накопления чтения
        // BufferedOutputStream: buf[8192] в heap для накопления записи
        // Итого: ~16KB в heap на время копирования
        
        try (BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(sourcePath), BUFFER_SIZE);
             BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destPath), BUFFER_SIZE)) {
            
            int bytesRead;
            // Цикл без аллокаций в heap — GC не вовлечен
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }
            
            // Явный flush для гарантии сброса остатка
            bos.flush();
            
        } // Автоматический close() для обоих потоков
        
        // buffer, bis.buf, bos.buf — все становятся недостижимым
        // GC собирает при следующей minor collection
    }
    
    // Альтернатива: без внешнего буфера, используя внутренние буферы оберток
    public static void copyOptimized(String sourcePath, String destPath) throws IOException {
        try (BufferedInputStream bis = new BufferedInputStream(
                new FileInputStream(sourcePath));
             BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(destPath))) {
            
            int byteValue;
            // Побайтово, но фактически буферизовано
            // Внешний буфер не нужен — экономия 8KB в heap
            while ((byteValue = bis.read()) != -1) {
                bos.write(byteValue);
            }
        }
    }
}

import java.io.*;

public class Task150626 {
    public static void main(String[] args) throws IOException {
        
        File f = new File("data.txt");
        
        FileOutputStream fos = new FileOutputStream(f);
        
        BufferedOutputStream bos = new BufferedOutputStream(fos, 1024);
        
        bos.write("Java".getBytes());
        System.out.println(f.length());
        bos.close();
        System.out.println(f.length());
    }
}

import java.util.Optional;
import java.io.Serializable;

public class OptionalUsage {
    
    //Антипаттерн: Optional как поле класса
    static class BadEntity implements Serializable {
        private Optional<String> name = Optional.empty(); // Не сериализуется!
        private Optional<Integer> age;                    // Hibernate не поймет
        // getter/setter
    }
    
    //Правильно: просто nullable поле
    static class GoodEntity implements Serializable {
        private String name;        // null = отсутствует
        private Integer age;        // null = отсутствует
    }
    
    //Антипаттерн: Optional в параметре метода
    public static void badMethod(Optional<String> param) {
        // Вызывающему нужно писать badMethod(Optional.of("text"))
        if (param.isPresent()) { /* ... */ }
    }
    
    //Решение 1: перегрузка метода
    public static void goodMethod() {
        // без параметра
    }
    
    public static void goodMethod(String param) {
        // с параметром (может быть null)
    }
    
    //Решение 2: проверка на null
    public static void betterMethod(String param) {
        if (param != null) { /* ... */ }
    }
    
    //Единственное правильное место: возвращаемое значение
    public static Optional<String> findUserById(long id) {
        // поиск в БД
        return id > 0 ? Optional.of("User") : Optional.empty();
    }
    
    public static void main(String[] args) {
        // Использование Optional из возврата
        findUserById(10).ifPresent(System.out::println);
        
        // Перегрузка вместо Optional параметра
        goodMethod(); // без параметра
        goodMethod("text"); // с параметром
    }
}

import java.io.*;
import java.util.Optional;

class Data160626 implements Serializable {
    Optional<String> value = Optional.of("secret");
}

public class Task160626 {
    public static void main(String[] args) throws Exception {
        Data160626 d = new Data160626();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(d);
        oos.close();
        
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
        Data160626 d2 = (Data160626) ois.readObject();
        System.out.println(d2.value.get());
    }
}

public abstract class Reader implements Readable, Closeable {
    // Чтение одного символа (char как int для EOF-различения)
    public int read() throws IOException
    
    // Чтение в массив char[]
    public int read(char[] cbuf) throws IOException
    
    // Чтение в массив с офсетом
    public abstract int read(char[] cbuf, int off, int len) throws IOException
    
    // Пропуск символов
    public long skip(long n) throws IOException
    
    // Готовность к чтению без блокировки
    public boolean ready() throws IOException
    
    // Поддержка mark/reset
    public boolean markSupported()
    public void mark(int readAheadLimit) throws IOException
    public void reset() throws IOException
    
    // Закрытие
    public abstract void close() throws IOException
}

public abstract class Writer implements Appendable, Closeable, Flushable {
    // Запись одного символа
    public void write(int c) throws IOException
    
    // Запись массива char[]
    public void write(char[] cbuf) throws IOException
    
    // Запись части массива
    public abstract void write(char[] cbuf, int off, int len) throws IOException
    
    // Запись строки
    public void write(String str) throws IOException
    
    // Запись части строки
    public void write(String str, int off, int len) throws IOException
    
    // Добавление (append)
    public Writer append(CharSequence csq) throws IOException
    
    // Сброс
    public abstract void flush() throws IOException
    
    // Закрытие
    public abstract void close() throws IOException
}

// Пример: эмодзи U+1F600 (😀) — суррогатная пара в Java
String emoji = "😀";
System.out.println(emoji.length()); // 2 — два char
System.out.println(emoji.codePointAt(0)); // 128512 — U+1F600

// Итерация по кодовым точкам, а не char
for (int cp : emoji.codePoints().toArray()) {
    System.out.println("Code point: U+" + Integer.toHexString(cp));
}

try (FileReader reader = new FileReader("text.txt")) {
    int charValue;
    while ((charValue = reader.read()) != -1) {
        processChar((char) charValue);
    }
}

[Диск: файл в байтах UTF-8]
  -> [Page Cache ОС: байты файла]
    -> [FileInputStream (underlying FileReader): чтение байтов]
      -> [InputStreamReader: декодирование байт -> char]
        -> [CharsetDecoder UTF-8: конечный автомат для мультибайтовых последовательностей]
          -> [char[] буфер декодера в heap]
            -> [FileReader.read(): возврат char как int]
              -> [Java-код: processChar()]

// Антипаттерн: зависимость от кодировки платформы
FileReader reader = new FileReader("text.txt"); // Неявная кодировка!

// Правильно: явное указание кодировки
InputStreamReader reader = new InputStreamReader(
    new FileInputStream("text.txt"), StandardCharsets.UTF_8);

// Упрощенная логика декодирования
ByteBuffer in = ByteBuffer.allocate(8192);  // Входные байты из потока
CharBuffer out = CharBuffer.allocate(8192); // Выходные символы

// Чтение байт из FileInputStream
int bytesRead = fileInputStream.read(in.array());
in.position(0).limit(bytesRead);

// Декодирование
CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
CoderResult result = decoder.decode(in, out, false);

// Извлечение символов
char[] chars = new char[out.position()];
out.flip().get(chars);

try (FileWriter writer = new FileWriter("output.txt")) {
    writer.write("Hello, 世界! 🌍");
}

[Java-код: String "Hello, 世界! 🌍"]
  -> [String.getBytes() или прямая работа с char[]]
    -> [FileWriter (наследник OutputStreamWriter)]
      -> [CharsetEncoder UTF-8: кодирование char -> байты]
        -> [ByteBuffer буфер кодера в heap]
          -> [FileOutputStream (underlying): запись байт]
            -> [Page Cache ОС: dirty pages]
              -> [Фоновая запись на диск]

public void processTextFiles(List<String> paths) throws IOException {
    for (String path : paths) {
        // Каждая итерация создает:
        // - FileInputStream (heap)
        // - InputStreamReader (heap)
        // - CharsetDecoder (heap)
        // - ByteBuffer/CharBuffer внутренние (heap)
        // - char[] для чтения (heap)
        
        try (InputStreamReader reader = new InputStreamReader(
                new FileInputStream(path), StandardCharsets.UTF_8)) {
            
            char[] buffer = new char[4096];
            int charsRead;
            while ((charsRead = reader.read(buffer)) != -1) {
                process(buffer, charsRead);
            }
            
        } // close() освобождает ресурсы, объекты становятся недостижимыми
        
        // GC собирает все созданные объекты при следующей minor collection
    }
}

// Переиспользуемый буфер
private static final ThreadLocal<char[]> CHAR_BUFFER = 
    ThreadLocal.withInitial(() -> new char[8192]);

public void processStream(InputStream in) throws IOException {
    char[] buffer = CHAR_BUFFER.get();
    
    try (InputStreamReader reader = new InputStreamReader(in, StandardCharsets.UTF_8)) {
        int charsRead;
        while ((charsRead = reader.read(buffer)) != -1) {
            process(buffer, charsRead);
        }
    }
    // reader и его декодер собираются GC
    // buffer остается в ThreadLocal, не подлежит GC
}

// Антипаттерн: чтение всего файла в одну строку
String content = new String(Files.readAllBytes("huge.txt"), StandardCharsets.UTF_8);

try (BufferedReader br = new BufferedReader(
        new InputStreamReader(
            new FileInputStream("text.txt"), StandardCharsets.UTF_8), 8192)) {
    
    String line;
    while ((line = br.readLine()) != null) {
        processLine(line);
    }
}

// Путь данных readLine():
// 1. Чтение блока символов в cb[8192] из underlying Reader
// 2. Поиск \n в cb
// 3. new String(cb, start, end - start) — создание String в heap
// 4. Возврат String
// 5. Следующий вызов: повторение