// Упрощенная структура из 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());
    }
}