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(); // Платформенно-независимый разделитель
    }
}

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

public class Task190626 {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        OutputStreamWriter writer = new OutputStreamWriter(baos, StandardCharsets.US_ASCII);
        writer.write('€');
        writer.flush();

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        InputStreamReader reader = new InputStreamReader(bais, StandardCharsets.US_ASCII);
        int ch = reader.read();
        System.out.println(ch);
    }
}

public class StreamIteratePredicate {
    
    public static void main(String[] args) {
        //Java 8: бесконечный стрим + limit
        Stream.iterate(1, i -> i * 2)
              .limit(5)
              .forEach(System.out::println); // 1, 2, 4, 8, 16
    
        //Java 9: ограниченный стрим через predicate (проверка ДО генерации)
        Stream.iterate(1, i -> i <= 16, i -> i * 2)
              .forEach(System.out::println); // 1, 2, 4, 8, 16 (включает 16, т.к. проверка на 16 == true)
    
        // Внимание: если начальное значение не удовлетворяет предикату — стрим пуст
        Stream.iterate(100, i -> i <= 16, i -> i / 2)
              .forEach(System.out::println); // Нет вывода!
    
        //Опасный пример: предикат всегда true — бесконечный стрим (без limit)
        // Stream.iterate(1, i -> true, i -> i + 1).forEach(...) // зависнет
    
        //Альтернатива с takeWhile (Java 9) — условие проверяется ПОСЛЕ генерации
        Stream.iterate(1, i -> i * 2)
              .takeWhile(i -> i <= 16)
              .forEach(System.out::println); // 1, 2, 4, 8, 16
    
        // Разница: если нужно включить элемент, который не удовлетворяет условию — takeWhile подходит
        // Например, генерация чисел до первого, превышающего 5
        Stream.iterate(1, i -> i + 1)
              .takeWhile(i -> i <= 5)
              .forEach(System.out::println); // 1,2,3,4,5 (включает 5)
    
        // Но с iterate с predicate: если i = 6, то предикат i <= 5 даст false до генерации 6, поэтому 5 включена
        Stream.iterate(1, i -> i <= 5, i -> i + 1)
              .forEach(System.out::println); // 1,2,3,4,5 — то же самое
    }
}