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 — то же самое
    }
}

import java.util.stream.Stream;

public class Task220626 {
    public static void main(String[] args) {
        Stream.iterate(1, i -> i <= 3, i -> i + 1)
              .peek(System.out::print)
              .anyMatch(i -> i > 1);
    }
}

// Упрощенная структура из OpenJDK
public class BufferedReader extends Reader {
    // Буфер символов в heap JVM
    private char[] cb;
    
    // Количество символов в буфере
    private int nChars;
    
    // Текущая позиция чтения
    private int nextChar;
    
    // Маркер для mark/reset
    private int markedChar = UNMARKED;
    private int readAheadLimit = 0;
    
    // Признак пропуска \n после \r
    private boolean skipLF = false;
    
    // Конструкторы
    public BufferedReader(Reader in) {
        this(in, defaultCharBufferSize); // 8192 по умолчанию
    }
    
    public BufferedReader(Reader in, int sz) {
        super(in);
        if (sz <= 0)
            throw new IllegalArgumentException("Buffer size <= 0");
        cb = new char[sz]; // Выделение в heap
    }
}

// Упрощенная логика readLine()
public String readLine() throws IOException {
    StringBuilder sb = new StringBuilder(defaultExpectedLineLength);
    
    while (true) {
        if (nextChar >= nChars) {
            fill(); // Заполнение буфера из underlying Reader
            if (nextChar >= nChars) {
                // Конец потока
                return sb.length() > 0 ? sb.toString() : null;
            }
        }
        
        char c = cb[nextChar++];
        
        if (c == '\n') {
            if (skipLF) {
                skipLF = false;
                continue; // Пропуск \n после \r
            }
            return sb.toString(); // Строка завершена
        }
        
        if (c == '\r') {
            skipLF = true;
            return sb.toString(); // Строка завершена, \n будет пропущен
        }
        
        sb.append(c); // Накопление символов
    }
}

[Диск: файл в байтах UTF-8]
  -> [Page Cache ОС]
    -> [FileInputStream: системный вызов read()]
      -> [InputStreamReader: декодирование байт -> char]
        -> [BufferedReader.fill(): копирование char[] в cb[8192]]
          -> [BufferedReader.readLine(): поиск \n в cb]
            -> [StringBuilder: накопление символов строки]
              -> [StringBuilder.toString(): создание String в heap]
                -> [Возврат String]

// Длинная строка превышает начальную емкость StringBuilder
StringBuilder sb = new StringBuilder(80); // Начальный массив char[80]
// Строка длиной 200 символов
// sb расширяется: char[80] -> char[160] -> char[320] -> ...
// Старые массивы становятся мусором

public long countLines(String path) throws IOException {
    long lineCount = 0;
    
    try (BufferedReader reader = new BufferedReader(
            new InputStreamReader(
                new FileInputStream(path), StandardCharsets.UTF_8))) {
        
        String line;
        while ((line = reader.readLine()) != null) {
            lineCount++;
            // line — новая String в heap
            // StringBuilder и его внутренний char[] — мусор
        }
        
    } // reader закрыт, cb освобожден
    
    return lineCount;
}

// Антипаттерн: удержание всех строк в памяти
public List<String> readAllLines(String path) throws IOException {
    List<String> lines = new ArrayList<>();
    
    try (BufferedReader reader = new BufferedReader(
            new InputStreamReader(new FileInputStream(path), StandardCharsets.UTF_8))) {
        
        String line;
        while ((line = reader.readLine()) != null) {
            lines.add(line); // Все String удерживаются списком
        }
    }
    
    return lines; // Возврат: все строки в heap
}

// Правильно: потоковая обработка без хранения всех строк
public void processLines(String path, Consumer<String> processor) throws IOException {
    try (BufferedReader reader = new BufferedReader(
            new InputStreamReader(new FileInputStream(path), StandardCharsets.UTF_8))) {
        
        String line;
        while ((line = reader.readLine()) != null) {
            processor.accept(line);
            // line становится недостижимой после итерации, если processor не сохраняет
        }
    }
}