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 не сохраняет
        }
    }
}

// Антипаттерн: удержание всех строк в памяти
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 не сохраняет
        }
    }
}

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

public class LineCounter {
    
    public LineStats analyzeFile(String path) throws IOException {
        long lineCount = 0;
        long totalChars = 0;
        long maxLineLength = 0;
        String longestLine = null;
        
        // BufferedReader с underlying InputStreamReader и FileInputStream
        // cb[8192] создается в heap при конструировании
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(
                    new FileInputStream(path), StandardCharsets.UTF_8))) {
            
            String line;
            while ((line = reader.readLine()) != null) {
                lineCount++;
                long lineLength = line.length();
                totalChars += lineLength;
                
                if (lineLength > maxLineLength) {
                    maxLineLength = lineLength;
                    longestLine = line; // Сохранение ссылки — String остается в heap!
                }
            }
            
        } // close() освобождает cb, но longestLine удерживается
        
        return new LineStats(lineCount, totalChars, maxLineLength, longestLine);
    }
    
    public record LineStats(long lineCount, long totalChars, 
                           long maxLineLength, String longestLine) {}
}

// Если нужна только длина, не хранить строку
public LineStats analyzeFileOptimized(String path) throws IOException {
    long lineCount = 0;
    long totalChars = 0;
    long maxLineLength = 0;
    
    try (BufferedReader reader = new BufferedReader(
            new InputStreamReader(new FileInputStream(path), StandardCharsets.UTF_8))) {
        
        String line;
        while ((line = reader.readLine()) != null) {
            lineCount++;
            long lineLength = line.length();
            totalChars += lineLength;
            maxLineLength = Math.max(maxLineLength, lineLength);
            // line не сохраняется — собирается GC
        }
    }
    
    return new LineStats(lineCount, totalChars, maxLineLength, null);
}

// Строка длиной 100 000 символов без \n
// readLine() выполняет ~13 вызовов fill(), накапливая в StringBuilder

StringBuilder sb = new StringBuilder(80); // Начальный массив char[80]
// При достижении 80: расширение до 160, копирование
// При достижении 160: расширение до 320, копирование
// ...
// Итоговый массив char[131072] для 100000 символов

// Если известна ожидаемая длина строки
StringBuilder sb = new StringBuilder(expectedLineLength);

// Потоковое чтение без явного BufferedReader
public long countLinesStream(String path) throws IOException {
    try (Stream<String> lines = Files.lines(Path.of(path), StandardCharsets.UTF_8)) {
        return lines.count();
    }
}

import java.io.*;

public class Task230626 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new StringReader("Hello"));
        br.reset();
        System.out.println("Done");
    }
}

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

public class ToMapDuplicate {
    
    public static void main(String[] args) {
        List<String> items = Arrays.asList("apple", "banana", "apple", "cherry");
        
        //Антипаттерн: выбросит IllegalStateException
        try {
            Map<String, Integer> bad = items.stream()
                .collect(Collectors.toMap(s -> s, String::length));
        } catch (IllegalStateException e) {
            System.err.println("Duplicate key: " + e.getMessage());
        }
        
        //Решение 1: оставить первое значение
        Map<String, Integer> first = items.stream()
            .collect(Collectors.toMap(
                s -> s,
                String::length,
                (oldVal, newVal) -> oldVal
            ));
        System.out.println("First: " + first); // {banana=6, apple=5, cherry=6}
        
        //Решение 2: взять последнее значение (часто для перезаписи)
        Map<String, Integer> last = items.stream()
            .collect(Collectors.toMap(
                s -> s,
                String::length,
                (old, newVal) -> newVal
            ));
        System.out.println("Last: " + last);
        
        //Решение 3: объединить значения (например, список длин)
        Map<String, List<Integer>> grouped = items.stream()
            .collect(Collectors.toMap(
                s -> s,
                s -> new ArrayList<>(List.of(s.length())),
                (list1, list2) -> { list1.addAll(list2); return list1; }
            ));
        System.out.println("Grouped: " + grouped);
        
        //Альтернатива: groupingBy для агрегации
        Map<String, Long> countByKey = items.stream()
            .collect(Collectors.groupingBy(
                s -> s,
                Collectors.counting()
            ));
        System.out.println("Counts: " + countByKey);
    }
}

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

public class Task240626 {
    static class Person240626 {
        int id;
        String name;
        Person240626(int id, String name) {
            this.id = id;
            this.name = name;
        }
    }

    public static void main(String[] args) {
        List<Person240626> people = Arrays.asList(
            new Person240626(1, "Alice"),
            new Person240626(2, "Bob"),
            new Person240626(1, "Charlie")
        );

        try {
            Map<Integer, String> map = people.stream()
                    .collect(
                            Collectors.toMap(p -> p.id, p -> p.name)
                    );
            
            System.out.println("Success");
            
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName());
        }
    }
}

// Упрощенная структура из OpenJDK
public class BufferedWriter extends Writer {
    // Внутренний буфер символов в heap JVM
    private char[] cb;
    
    // Текущая позиция записи в буфере
    private int nChars;
    
    // Ссылка на underlying Writer
    private Writer out;
    
    // Разделитель строки для newLine()
    private String lineSeparator;
    
    // Конструкторы
    public BufferedWriter(Writer out) {
        this(out, defaultCharBufferSize); // 8192 по умолчанию
    }
    
    public BufferedWriter(Writer out, int sz) {
        super(out);
        if (sz <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        this.out = out;
        cb = new char[sz]; // Выделение в heap: 8192 * 2 = 16384 байт
        nChars = 0;
        lineSeparator = System.lineSeparator(); // Платформенный разделитель
    }
}

public void write(String s, int off, int len) throws IOException {
    // Если строка не влезает в оставшийся буфер — сброс
    if (len >= cb.length - nChars) {
        flushBuffer(); // Сброс накопленного в underlying Writer
    }
    
    if (len >= cb.length) {
        // Строка больше буфера — запись напрямую, минуя буфер
        writeDirect(s, off, len);
    } else {
        // Копирование строки в буфер
        s.getChars(off, off + len, cb, nChars); // Быстрое копирование из String
        nChars += len;
    }
}

[Java: bw.write("Hello")]
  -> [BufferedWriter: len=5 < cb.length - nChars?]
    -> [s.getChars(0, 5, cb, nChars)] // Копирование char[] из String в buf
      -> [System.arraycopy: копирование 5 char в cb]
    -> [nChars += 5]
  -> [Возврат]

private void flushBuffer() throws IOException {
    if (nChars > 0) {
        out.write(cb, 0, nChars); // Запись в underlying Writer
        nChars = 0; // Сброс позиции
    }
}

[BufferedWriter: flushBuffer()]
  -> [OutputStreamWriter.write(cb, 0, nChars)]
    -> [StreamEncoder: кодирование char[] -> байты UTF-8]
      -> [ByteBuffer: накопление закодированных байт]
        -> [FileOutputStream.write(byte[]): системный вызов]
          -> [Нативный буфер userspace]
            -> [Ядро ОС: syscall write]
              -> [Page Cache: dirty pages]

public void newLine() throws IOException {
    write(lineSeparator); // Запись \n или \r\n из поля lineSeparator
}

// На Unix: запись \n
// На Windows: запись \r\n
// Результат одинаков для кода, различается для файла