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. Следующий вызов: повторение

import java.io.*;

public class Task170626 {
    public static void main(String[] args) throws IOException {
        StringReader sr = new StringReader("ABCDEFG");
        BufferedReader br = new BufferedReader(sr);

        System.out.print((char) br.read());
        br.mark(2);
        System.out.print((char) br.read());
        System.out.print((char) br.read());
        br.reset();
        System.out.print((char) br.read());
        System.out.print((char) br.read());
    }
}

import java.util.*;
import java.util.stream.*;

public class OptionalFlatMap {
    
    public static void main(String[] args) {
        List<Optional<String>> list = Arrays.asList(
            Optional.of("Java"),
            Optional.empty(),
            Optional.of("Kotlin"),
            Optional.empty()
        );
        
        //Антипаттерн: filter + map
        List<String> bad = list.stream()
            .filter(Optional::isPresent)
            .map(Optional::get)
            .collect(Collectors.toList());
        System.out.println("Filter+map: " + bad);
        
        //Решение: flatMap с Optional.stream (Java 9+)
        List<String> good = list.stream()
            .flatMap(Optional::stream) // Преобразует каждый Optional в стрим
            .collect(Collectors.toList());
        System.out.println("flatMap: " + good); // [Java, Kotlin]
        
        // Для Java 8: альтернатива
        List<String> java8 = list.stream()
            .flatMap(o -> o.map(Stream::of).orElseGet(Stream::empty))
            .collect(Collectors.toList());
        System.out.println("Java 8 flatMap: " + java8);
        
        // Работает и с другими Optional-подобными типами
        List<OptionalInt> optionalInts = Arrays.asList(
            OptionalInt.of(10),
            OptionalInt.empty(),
            OptionalInt.of(20)
        );
        
        // flatMap для OptionalInt требует преобразования в IntStream
        // Не так прямо, но идея та же.
    }
}

import java.util.*;

public class Task180626 {
    public static void main(String[] args) {
        List<Optional<String>> list = Arrays.asList(
            Optional.of("a"),
            null,
            Optional.of("b")
        );
        list.stream()
            .flatMap(Optional::stream)
            .forEach(System.out::print);
    }
}

// Антипаттерн: неявная кодировка платформы
try (FileReader reader = new FileReader("text.txt")) {
    // На Windows может использоваться windows-1251
    // На Linux — UTF-8
    // На macOS — UTF-8
    // Результат непредсказуем при переносе между системами
}

public InputStreamReader(InputStream in, Charset cs)

try (InputStreamReader reader = new InputStreamReader(
        new FileInputStream("text.txt"), StandardCharsets.UTF_8)) {
    
    int charValue;
    while ((charValue = reader.read()) != -1) {
        System.out.print((char) charValue);
    }
}

[Файл на диске: байты UTF-8]
  -> [Page Cache ОС: байты файла]
    -> [FileInputStream.read(byte[]) — системный вызов]
      -> [Нативный буфер userspace]
        -> [JNI: копирование в byte[] внутри InputStreamReader]
          -> [InputStreamReader: накопление байт во внутреннем ByteBuffer]
            -> [CharsetDecoder UTF-8: конечный автомат декодирования]
              -> [CharBuffer: накопление декодированных символов]
                -> [read(): возврат char как int]
                  -> [System.out.print(char): кодирование в байты платформы]

// Упрощенная структура
public class InputStreamReader extends Reader {
    private final StreamDecoder sd; // Делегат декодирования
    
    // StreamDecoder содержит:
    // - ByteBuffer: входные байты из потока
    // - CharBuffer: выходные символы
    // - CharsetDecoder: конечный автомат кодировки
}

// Сценарий: 3-байтовый символ '世' (U+4E16, E4 B8 96) разбит между чтениями

// Первое чтение: получены байты [..., E4, B8] — неполная последовательность
// StreamDecoder сохраняет E4 B8 во внутреннем ByteBuffer, возвращает 0 символов

// Второе чтение: получен байт [96, ...] — завершение последовательности
// StreamDecoder комбинирует E4 B8 96, декодирует в U+4E16, возвращает '世'

public OutputStreamWriter(OutputStream out, Charset cs)

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

[Java-код: String "Hello, 世界! 🌍"]
  -> [String.toCharArray() или прямой доступ к внутреннему char[]]
    -> [OutputStreamWriter.write(char[], off, len)]
      -> [StreamEncoder: кодирование char -> байты]
        -> [CharsetEncoder UTF-8: конечный автомат]
          -> [ByteBuffer: накопление закодированных байт]
            -> [FileOutputStream.write(byte[]): системный вызов]
              -> [Нативный буфер userspace]
                -> [Ядро ОС: syscall write]
                  -> [Page Cache: dirty pages]
                    -> [Фоновая запись на диск]

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

public class Utf8FileProcessor {
    
    public void readAndPrint(String path) throws IOException {
        // InputStreamReader: байты из файла -> символы UTF-8
        try (InputStreamReader reader = new InputStreamReader(
                new FileInputStream(path), StandardCharsets.UTF_8)) {
            
            char[] buffer = new char[1024];
            int charsRead;
            
            // Буферизованное чтение символов
            while ((charsRead = reader.read(buffer)) != -1) {
                // Создание String из char[] — новый объект в heap
                String chunk = new String(buffer, 0, charsRead);
                System.out.print(chunk);
            }
        }
        // reader закрыт, StreamDecoder и его буферы освобождены
        // buffer и chunk — недостижимы, GC собирает при следующей minor collection
    }
    
    // Альтернатива: BufferedReader для построчного чтения
    public void readLines(String path) throws IOException {
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(
                    new FileInputStream(path), StandardCharsets.UTF_8))) {
            
            String line;
            int lineNumber = 0;
            while ((line = reader.readLine()) != null) {
                lineNumber++;
                System.out.printf("%d: %s%n", lineNumber, line);
                // Каждая line — новая String в heap
            }
        }
        // Все String из readLine() недостижимы, если не сохранены
    }
}

[BufferedReader.readLine()]
  -> [Заполнение cb[8192] из underlying InputStreamReader]
    -> [InputStreamReader: декодирование байт -> символы]
      -> [Поиск \n или \r\n в cb]
        -> [new String(cb, start, length): создание String в heap]
          -> [String конструктор: копирование char[] (или byte[] в современных JDK)]
            -> [Возврат String]

public void processManyFiles(List<String> paths) throws IOException {
    for (String path : paths) {
        // Каждая итерация создает:
        // - FileInputStream (heap)
        // - InputStreamReader (heap)
        // - StreamDecoder (heap)
        // - ByteBuffer, CharBuffer внутренние (heap)
        // - CharsetDecoder (heap)
        // - char[] buffer (heap)
        // - String chunk (heap, при каждом read)
        
        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(new String(buffer, 0, charsRead));
            }
        }
        // Все объекты становятся недостижимыми
        // GC собирает их при следующей minor collection
    }
}

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

public void processFileOptimized(String path) throws IOException {
    char[] buffer = CHAR_BUFFER.get();
    
    try (InputStreamReader reader = new InputStreamReader(
            new FileInputStream(path), StandardCharsets.UTF_8)) {
        
        int charsRead;
        while ((charsRead = reader.read(buffer)) != -1) {
            // String всё еще создается, но buffer переиспользуется
            process(new String(buffer, 0, charsRead));
        }
    }
}

public void writeUtf8File(String path, List<String> lines) throws IOException {
    // OutputStreamWriter: символы -> байты UTF-8
    try (OutputStreamWriter writer = new OutputStreamWriter(
            new FileOutputStream(path), StandardCharsets.UTF_8)) {
        
        for (String line : lines) {
            writer.write(line);      // Кодирование char[] -> байты UTF-8
            writer.write(System.lineSeparator());
        }
        
        writer.flush(); // Сброс внутренних буферов в FileOutputStream
        
    } // close() с неявным flush()
    
    // StreamEncoder и его буферы освобождены
}

try (BufferedWriter writer = new BufferedWriter(
        new OutputStreamWriter(
            new FileOutputStream(path), StandardCharsets.UTF_8))) {
    
    for (String line : lines) {
        writer.write(line);
        writer.newLine(); // Платформенно-независимый разделитель
    }
}