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

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