// Бесконечная последовательность: 0, 1, 2, 3...
Stream<Integer> natural = Stream.iterate(0, n -> n + 1);

// Бесконечный поток случайных книг
Stream<Book> randomBooks = Stream.generate(() -> generateRandomBook());

// Хорошо делится: ArrayList, массивы, IntStream.range
List<Book> books = new ArrayList<>();
books.parallelStream()  // Эффективное распараллеливание

// Плохо делится: Stream.iterate, Stream.generate, BufferedReader.lines()
Stream.iterate(0, n -> n + 1).parallel()  // Нет выигрыша, возможен проигрыш

// Упрощённая внутренняя структура (псевдокод на основе OpenJDK)
abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>> 
    extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> {
    
    private final AbstractPipeline<?, E_IN, ?> previousStage;  // Ссылка назад
    private AbstractPipeline<?, E_OUT, ?> nextStage;           // Ссылка вперёд
    private int depth;  // Глубина в конвейере
    
    // Каждая операция оборачивает предыдущую
    protected AbstractPipeline(AbstractPipeline<?, E_IN, ?> previousStage, int opFlags) {
        this.previousStage = previousStage;
        this.depth = previousStage.depth + 1;
        previousStage.nextStage = this;
    }
}

stream.filter(...).map(...).sorted(...)

// Упрощённая логика терминальной операции (псевдокод)
public void evaluateParallel(PipelineHelper<T> helper, Spliterator<S> spliterator) {
    // Создаём приёмник для конечной операции (например, collecting)
    Sink<T> sink = makeSink();
    
    // Оборачиваем в приёмники промежуточных операций, идя от хвоста к голове
    for (AbstractPipeline p = lastStage; p != null; p = p.previousStage) {
        sink = p.opWrapSink(sink);
    }
    
    // Запускаем обход источника
    spliterator.forEachRemaining(sink::accept);
}

Stream<Book> stream = books.stream();
List<Book> first = stream.collect(toList());  // OK
List<Book> second = stream.collect(toList()); // IllegalStateException: stream has already been operated upon or closed

Supplier<Stream<Book>> streamSupplier = () -> books.stream();
List<Book> first = streamSupplier.get().collect(toList());
List<Book> second = streamSupplier.get().filter(Book::isAvailable).collect(toList());

Stream.iterate(0, n -> n + 1)
    .sorted()        // Опасность: попытка отсортировать бесконечность
    .findFirst();    // Никогда не выполнится

import java.util.Arrays;
import java.util.stream.Stream;

public class Task120226 {
    public static void main(String[] args) {
        String[] array = {"a", "b", "c"};
        Stream<String> s1 = Arrays.stream(array);
        Stream<String> s2 = Stream.of(array);
        
        array[1] = "X";
        
        System.out.println(s1.findFirst().orElse(""));
        System.out.println(s2.skip(1).findFirst().orElse(""));
    }
}

import java.io.*;
import java.nio.file.*;
import java.sql.*;

public class ResourceManagement {
    public static void main(String[] args) {
        Path file = Paths.get("example.txt");

        //Антипаттерн: Ручное закрытие с уязвимостями.
        BufferedReader reader = null;
        try {
            reader = Files.newBufferedReader(file);
            String line = reader.readLine();
            System.out.println(line);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (reader != null) {
                try {
                    reader.close(); // Дополнительный try-catch и риск потери исключения
                } catch (IOException e) {
                    e.printStackTrace(); // Может затереть исходное исключение
                }
            }
        }

        //Решение: try-with-resources.
        try (BufferedReader br = Files.newBufferedReader(file);
             FileWriter fw = new FileWriter("output.txt")) { // Несколько ресурсов
            String line = br.readLine();
            fw.write(line);
        } catch (IOException e) {
            // Исключения из close() доступны через e.getSuppressed()
            System.out.println("Основное исключение: " + e);
            for (Throwable suppressed : e.getSuppressed()) {
                System.out.println("Подавленное: " + suppressed);
            }
        }

        // Пример с JDBC: ресурсы должны быть объявлены в правильном порядке.
        String url = "jdbc:h2:mem:test";
        String sql = "SELECT * FROM users";
        try (Connection conn = DriverManager.getConnection(url);
             Statement stmt = conn.createStatement();
             ResultSet rs = stmt.executeQuery(sql)) {
            while (rs.next()) {
                // Обработка результата
            }
        } catch (SQLException e) {
            // Автоматическое закрытие Connection, Statement, ResultSet
        }
    }
}

import java.util.Optional;

class Box130226 {
    int value;
    Box130226(int value) { this.value = value; }
}

public class Task130226 {
    public static void main(String[] args) {
        Box130226 box = new Box130226(10);
        Optional<Box130226> opt = Optional.of(box);
        
        opt.ifPresent(b -> b.value = 20);
        opt.filter(b -> b.value > 15)
           .map(b -> { b.value = 30; return b; });
        
        System.out.println(box.value);
    }
}

Stream<Book> stream = library.getBooks().stream()
    .peek(book -> System.out.println("Просматриваем: " + book.title()))
    .filter(book -> book.year() > 1950);

System.out.println("Конвейер построен");
// На консоли только: "Конвейер построен"
// Ни одной строки "Просматриваем..." не появится

Optional<ProcessedBook> result = books.stream()
    .map(b -> heavyTransform(b))           // Тяжёлая операция для ВСЕХ книг
    .filter(b -> b.price() > 100)          // Фильтрация уже обработанных
    .findFirst();                          // Возврат первой подходящей

Optional<ProcessedBook> result = books.stream()
    .filter(b -> b.price() > 100)          // Сначала дешёвая проверка
    .map(b -> heavyTransform(b))           // Тяжёлая операция только для подходящих
    .findFirst();                          // Остановка после первой успешной

// Упрощённая логика findFirst (псевдокод)
public Optional<T> findFirst() {
    final AtomicReference<T> result = new AtomicReference<>();
    
    evaluate(new TerminalSink<T, Void>() {
        boolean found = false;
        
        @Override
        public void accept(T value) {
            if (!found) {
                result.set(value);
                found = true;
                // Запрос отмены дальнейшего обхода
                cancellationRequested = true;  
            }
        }
        
        @Override
        public boolean cancellationRequested() {
            return found;  // Сигнализируем об остановке
        }
    });
    
    return found ? Optional.of(result.get()) : Optional.empty();
}

// Эффективный поиск: остановка при первом совпадении
boolean hasExpensive = books.stream()
    .anyMatch(b -> b.price() > 1000);  // Проверяет до первого совпадения, не все

// Неэффективная альтернатива
boolean hasExpensive = books.stream()
    .filter(b -> b.price() > 1000)
    .findFirst()
    .isPresent();  // Больше объектов создаётся, но семантически эквивалентно

Stream.iterate(0, i -> i + 1)  // Бесконечная последовательность
    .filter(i -> i % 2 == 0)   // Чётные числа — тоже бесконечно
    .limit(10)                  // Ограничение делает конечным
    .forEach(System.out::println);  // Выводит 0, 2, 4, 6, 8, 10, 12, 14, 16, 18

books.stream()
    .filter(b -> { 
        System.out.println("Filter: " + b.title()); 
        return b.year() > 1950; 
    })
    .map(b -> {
        System.out.println("Map: " + b.title());
        return b.title().toUpperCase();
    })
    .limit(2)
    .forEach(System.out::println);

Filter: Book A (1900)     // Отсеян, Map не вызывается
Filter: Book B (1960)     // Прошёл
Map: Book B               // Преобразован
BOOK B                    // forEach
Filter: Book C (1970)     // Прошёл
Map: Book C               // Преобразован
BOOK C                    // forEach
// limit(2) достигнут, остановка

Stream<Book> stream = books.stream()
    .map(b -> {
        if (b.year() < 0) throw new IllegalStateException("Invalid year: " + b.year());
        return b;
    });
// Исключение не брошено

stream.forEach(System.out::println);  // Исключение здесь, стектрейс указывает на forEach

books.stream()
    .map(b -> {
        if (b.year() < 0) throw new IllegalStateException("Invalid year");
        return b;
    })
    .findFirst();  // Если первая книга валидна, исключение для второй (с ошибкой) не бросится

import java.util.function.Function;

public class Task160226 {
    public static void main(String[] args) {
        Function<Integer, Integer> f1 = i -> i * 2;
        Function<Integer, Integer> f2 = i -> i + 1;
        Function<Integer, Integer> f3 = f1.compose(f2);
        Function<Integer, Integer> f4 = f1.andThen(f2);
        
        System.out.println(f3.apply(5) + " " + f4.apply(5));
    }
}