// Упрощенная структура из OpenJDK
public class PrintWriter extends Writer {
    // Underlying Writer для фактической записи
    private Writer out;
    
    // Флаг autoFlush: сброс буфера после println()
    private boolean autoFlush;
    
    // Флаг ошибки: true, если произошла IOException
    private boolean trouble = false;
    
    // Конструкторы
    public PrintWriter(Writer out) {
        this(out, false); // autoFlush = false по умолчанию
    }
    
    public PrintWriter(Writer out, boolean autoFlush) {
        super(out);
        this.out = out;
        this.autoFlush = autoFlush;
    }
    
    public PrintWriter(String fileName) throws FileNotFoundException {
        this(new BufferedWriter(new OutputStreamWriter(
            new FileOutputStream(fileName))), false);
    }
}

PrintWriter
  -> Writer (FileWriter)
    -> FileWriter extends OutputStreamWriter
      -> FileOutputStream (внутри OutputStreamWriter)

// Правильно: буферизация через BufferedWriter
new PrintWriter(new BufferedWriter(new FileWriter("file.txt")));

public void print(String s) {
    if (s == null) {
        s = "null";
    }
    write(s); // Делегирование в underlying Writer
}

public void println(String s) {
    print(s);
    println(); // Запись разделителя строки
}

public void println() {
    // Запись line.separator
    write(System.lineSeparator());
    if (autoFlush) {
        flush(); // Сброс при autoFlush=true
    }
}

public PrintWriter printf(String format, Object... args) {
    return format(format, args);
}

public PrintWriter format(String format, Object... args) {
    try {
        Formatter f = new Formatter(this);
        f.format(format, args);
    } catch (FormatterClosedException x) {
        // Обработка
    }
    return this;
}

try (PrintWriter pw = new PrintWriter(
        new BufferedWriter(new FileWriter("report.txt")))) {
    
    pw.printf("Book: %s, Author: %s, Price: %.2f%n", 
        book.getTitle(), book.getAuthor(), book.getPrice());
}

[Java: pw.printf("Book: %s...", title, author, price)]
  -> [new Formatter(pw)] // Создание Formatter в heap
    -> [Formatter.parse(format)] // Парсинг строки формата
      -> [StringBuilder внутри Formatter: накопление результата]
        -> [%s: title.toString()] // Вызов toString(), создание String
        -> [%s: author.toString()] // Вызов toString(), создание String
        -> [%.2f: String.format("%.2f", price)] // Создание String
        -> [%n: замена на \n или \r\n]
      -> [Formatter.flush(): запись StringBuilder в PrintWriter]
        -> [PrintWriter.write(String)] // Делегирование в BufferedWriter
          -> [BufferedWriter.write(char[], off, len)] // Накопление в cb
            -> [OutputStreamWriter: кодирование char -> байты UTF-8]
              -> [FileOutputStream: системный вызов при заполнении/flush]

public void writeBooksCsv(String path, List<Book> books) throws IOException {
    // Объекты, создаваемые при конструировании:
    // - FileWriter (heap)
    // - BufferedWriter (heap) с cb[8192] (heap, 16KB)
    // - PrintWriter (heap)
    
    try (PrintWriter pw = new PrintWriter(
            new BufferedWriter(new FileWriter(path)))) {
        
        pw.println("Title,Author,Price,Year"); // Заголовок
        
        for (Book book : books) {
            // Каждая итерация:
            // - Formatter (временный, внутри printf)
            // - StringBuilder (временный, внутри Formatter)
            // - String от Double.toString() или String.format() (временный)
            // - char[] при записи в BufferedWriter (переиспользуется)
            
            pw.printf("%s,%s,%.2f,%d%n",
                escapeCsv(book.getTitle()),
                escapeCsv(book.getAuthor()),
                book.getPrice(),
                book.getYear());
            
            // Formatter и StringBuilder собираются GC
            // String от escapeCsv() — если не сохранена, собирается
        }
        
    } // close() с flush()
    
    // Все объекты недостижимы, GC собирает
}

// Антипаттерн для горячих путей: printf создает много временных объектов
pw.printf("%s,%s,%.2f,%d%n", title, author, price, year);

// Оптимизация: ручное форматирование через StringBuilder
// (но PrintWriter не предоставляет доступа к внутреннему буферу)
// Альтернатива: накопление в собственном StringBuilder, затем одна запись

StringBuilder sb = new StringBuilder(256);
for (Book book : books) {
    sb.setLength(0); // Сброс без создания нового объекта
    sb.append(escapeCsv(book.getTitle())).append(',')
      .append(escapeCsv(book.getAuthor())).append(',')
      .append(String.format("%.2f", book.getPrice())).append(',')
      .append(book.getYear()).append('\n');
    pw.write(sb.toString());
}

// autoFlush=true: flush() после каждого println()
try (PrintWriter pw = new PrintWriter(
        new BufferedWriter(new FileWriter("log.txt")), true)) {
    
    pw.println("Entry 1"); // Запись + flush()
    pw.println("Entry 2"); // Запись + flush()
    // Каждый flush() = сброс BufferedWriter -> OutputStreamWriter -> FileOutputStream
}

[println("Entry")]
  -> [print("Entry")]
    -> [BufferedWriter.write("Entry")] // Накопление в cb
  -> [println()]
    -> [write("\n")] // Накопление в cb
    -> [flush()] // СБРОС!
      -> [BufferedWriter.flushBuffer()]
        -> [OutputStreamWriter.write(cb, 0, n)]
          -> [StreamEncoder: кодирование]
            -> [FileOutputStream: системный вызов]
              -> [Page Cache]

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.List;

public class CsvBookWriter {
    
    public void writeBooks(String path, List<Book> books) throws IOException {
        // Цепочка оберток с буферизацией
        // PrintWriter -> BufferedWriter -> OutputStreamWriter -> FileOutputStream
        
        try (PrintWriter pw = new PrintWriter(
                new BufferedWriter(
                    new OutputStreamWriter(
                        new FileOutputStream(path), StandardCharsets.UTF_8)))) {
            
            // Заголовок CSV
            pw.println("id,title,author,price,year,pages");
            
            // Данные
            for (Book book : books) {
                pw.printf("%d,\"%s\",\"%s\",%.2f,%d,%d%n",
                    book.getId(),
                    escapeCsv(book.getTitle()),
                    escapeCsv(book.getAuthor()),
                    book.getPrice(),
                    book.getYear(),
                    book.getPages());
            }
            
            // Явный flush перед закрытием
            pw.flush();
            
            // Проверка ошибок
            if (pw.checkError()) {
                throw new IOException("Error occurred during writing");
            }
            
        } // close() с неявным flush()
    }
    
    // Экранирование спецсимволов CSV
    private String escapeCsv(String value) {
        if (value == null) return "";
        return value.replace("\"", "\"\"");
    }
    
    public record Book(int id, String title, String author, 
                      double price, int year, int pages) {}
}

[printf("%d,\"%s\",\"%s\",%.2f,%d,%d%n", ...)]
  -> [Formatter создан в heap]
    -> [StringBuilder внутри Formatter создан в heap]
      -> [Форматирование: "1,\"The Great Gatsby\",\"F. Scott Fitzgerald\",10.99,1925,180\n"]
        -> [toString() для title — уже String, новый объект не создан]
        -> [String.format("%.2f", 10.99) — создание String "10.99" в heap]
      -> [Formatter.flush(): запись в PrintWriter]
        -> [PrintWriter.write(String)]
          -> [BufferedWriter.write(char[], 0, len)]
            -> [Накопление в cb[8192]]
              -> [При заполнении cb: сброс в OutputStreamWriter]
                -> [Кодирование UTF-8]
                  -> [FileOutputStream: системный вызов]
  -> [Formatter и StringBuilder — недостижимы, GC собирает]

import java.io.*;

public class Task290626 {
    public static void main(String[] args) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (PrintWriter pw = new PrintWriter(baos, true)) {
            pw.print("Hello");
        }
        System.out.println(baos.size());
    }
}

public class CompletableFutureHandle {
    
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // Создаем будущее, которое завершится исключительно
        CompletableFuture<String> failedFuture = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Ошибка в задаче");
        });
        
        //thenApply не выполнится, исключение игнорируется
        CompletableFuture<String> badChain = failedFuture.thenApply(s -> s + " обработано");
        // badChain.get() выбросит ExecutionException с исходной ошибкой
        
        //handle: всегда вызывается, получает результат или исключение
        CompletableFuture<String> handled = failedFuture.handle((result, ex) -> {
            if (ex != null) {
                System.err.println("Ошибка: " + ex.getMessage());
                return "Значение по умолчанию";
            }
            return result + " (успех)";
        });
        System.out.println("handle result: " + handled.join()); // Значение по умолчанию
        
        //whenComplete: для логирования, не меняет результат
        CompletableFuture<String> logged = failedFuture.whenComplete((result, ex) -> {
            if (ex != null) {
                System.err.println("Логируем ошибку: " + ex);
            } else {
                System.out.println("Успешно: " + result);
            }
        });
        // logged по-прежнему будет завершено исключительно
        // logged.join() выбросит CompletionException
        
        // Обработка через exceptionally (только при ошибке)
        CompletableFuture<String> recovered = failedFuture.exceptionally(ex -> {
            System.err.println("Восстановление: " + ex);
            return "Восстановленное значение";
        });
        System.out.println("exceptionally: " + recovered.join());
        
        // Комбинирование: handle может изменить тип
        CompletableFuture<Integer> typed = failedFuture.handle((s, ex) -> {
            return ex != null ? -1 : s.length();
        });
        System.out.println("handle with type: " + typed.join()); // -1
    }
}

import java.util.concurrent.CompletableFuture;

public class Task300626 {
    public static void main(String[] args) throws Exception {
        CompletableFuture<String> future = new CompletableFuture<>();

        CompletableFuture<String> result = future
                .thenApply(s -> s + "!")
                .exceptionally(ex -> "fallback");

        future.completeExceptionally(new RuntimeException("Oops"));
        System.out.println(result.get());
    }
}

// Упрощенная структура из OpenJDK
public class SequenceInputStream extends InputStream {
    // Текущий активный поток
    private InputStream in;
    
    // Перечисление оставшихся потоков
    private Enumeration<InputStream> e;
    
    // Конструктор для двух потоков
    public SequenceInputStream(InputStream s1, InputStream s2) {
        Vector<InputStream> v = new Vector<>(2);
        v.addElement(s1);
        v.addElement(s2);
        e = v.elements();
        nextStream(); // Установка первого потока
    }
    
    // Конструктор для произвольного количества потоков
    public SequenceInputStream(Enumeration<InputStream> e) {
        this.e = e;
        nextStream(); // Установка первого потока
    }
    
    // Переключение на следующий поток
    private void nextStream() {
        if (in != null) {
            in.close(); // Закрытие исчерпанного потока
        }
        in = e.hasMoreElements() ? e.nextElement() : null;
    }
}

public int read() throws IOException {
    if (in == null) {
        return -1; // Все потоки исчерпаны
    }
    int c = in.read(); // Делегирование текущему потоку
    if (c == -1) {
        nextStream(); // Переключение на следующий
        return read(); // Рекурсивный вызов для нового потока
    }
    return c;
}

[Java: sis.read()]
  -> [SequenceInputStream: in != null?]
    -> [in.read()] // Делегирование текущему потоку
      -> [Например, FileInputStream.read()]
        -> [Системный вызов read()]
          -> [Page Cache -> нативный буфер -> byte в heap]
    -> [c == -1?] // Конец текущего потока?
      -> [Нет: возврат c]
      -> [Да: nextStream()]
        -> [in.close()] // Закрытие исчерпанного потока
        -> [in = e.nextElement()] // Следующий поток
        -> [Рекурсивный read()] // Чтение из нового потока

public int read(byte[] b, int off, int len) throws IOException {
    if (in == null) {
        return -1;
    }
    if (b == null) {
        throw new NullPointerException();
    }
    
    int n = in.read(b, off, len); // Попытка чтения из текущего потока
    if (n > 0) {
        return n; // Данные прочитаны
    }
    if (n == -1) {
        nextStream(); // Конец потока — переключение
        return read(b, off, len); // Рекурсивный вызов
    }
    // n == 0: поток вернул 0 байт, но не EOF
    return 0;
}