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

package com.example.model;

public enum OrderStatus {
    NEW("Новый") {
        @Override
        public void handle() {
            System.out.println("Проверка наличия товара для нового заказа");
        }
    },
    PROCESSING("В обработке") {
        @Override
        public void handle() {
            System.out.println("Передача в службу доставки");
        }
    },
    COMPLETED("Завершен") {
        @Override
        public void handle() {
            System.out.println("Отправка опроса удовлетворенности");
        }
    };

    private final String displayName;

    OrderStatus(String displayName) {
        this.displayName = displayName;
    }

    public String getDisplayName() { 
        return displayName; 
    }

    public abstract void handle();
}

// OrderService.java - Сервисный слой
package com.example.service;

import com.example.model.OrderStatus;

public class OrderService {
    
    public void processOrder(OrderStatus status) {
        if (status == null) {
            throw new IllegalArgumentException("Статус не может быть null");
        }
        
        status.handle();
        displayStatusInfo(status);
    }
    
    private void displayStatusInfo(OrderStatus status) {
        switch (status) {
            case NEW -> System.out.println("Отображение как: " + status.getDisplayName());
            case PROCESSING -> System.out.println("Отображение как: " + status.getDisplayName());
            case COMPLETED -> System.out.println("Отображение как: " + status.getDisplayName());
        }
    }
}

// Application.java - Точка входа
package com.example;

import com.example.model.OrderStatus;
import com.example.service.OrderService;

public class Application {
    public static void main(String[] args) {
        OrderService orderService = new OrderService();
        orderService.processOrder(OrderStatus.NEW);
    }
}

public class Task170226 {
    enum Color {
        RED, GREEN, BLUE;
        
        static {
            System.out.println("Static block");
        }
        
        Color() {
            System.out.println("Constructor: " + this);
        }
    }
    
    public static void main(String[] args) {
        System.out.println("Start");
        Color c = Color.RED;
        System.out.println("End");
    }
}

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))
    .map(i -> i * i)
    .peek(i -> System.out.println("mapped: " + i))

OptionalInt result = IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))
    .map(i -> i * i)
    .peek(i -> System.out.println("mapped: " + i))
    .findFirst();

source: 0
filtered: 0
mapped: 0
Почему только одна цепочка? Потому что findFirst() — короткозамкнутая операция. Как только найден первый подходящий элемент (0), выполнение останавливается. Остальные числа от 1 до 9 даже не достигают источника.

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))
    .map(i -> i * i)
    .peek(i -> System.out.println("mapped: " + i))
    .forEach(i -> System.out.println("result: " + i));

source: 0
filtered: 0
mapped: 0
result: 0
source: 1
source: 2
filtered: 2
mapped: 4
result: 4
source: 3
source: 4
filtered: 4
mapped: 16
result: 16
...

Элемент 0: source → filter → map → result
Элемент 1: source → (отфильтрован) → ...
Элемент 2: source → filter → map → result

Все source: 0,1,2,3,4,5,6,7,8,9
Все filtered: 0,2,4,6,8
Все mapped: 0,4,16,36,64

// Создаём полный список, сортируем, берём первый
List<Book> filtered = new ArrayList<>();
for (Book b : books) {
    if (b.getAuthor().equals("X")) {
        filtered.add(b);
    }
}
filtered.sort(Comparator.comparingInt(Book::getYear));
Book first = filtered.get(0);  // Всё равно обработали все книги

Optional<Book> first = books.stream()
    .filter(b -> b.getAuthor().equals("X"))
    .sorted(Comparator.comparingInt(Book::getYear))
    .findFirst();  // Остановится при первой найденной книге

IntStream.range(0, 10)
    .peek(i -> System.out.println("source: " + i))
    .map(i -> i * i)           // теперь раньше
    .peek(i -> System.out.println("mapped: " + i))
    .filter(i -> i % 2 == 0)   // теперь позже
    .peek(i -> System.out.println("filtered: " + i))
    .forEach(i -> System.out.println("result: " + i));

IntStream.range(0, 1000)  // большой диапазон
    .peek(i -> System.out.println("source: " + i))
    .filter(i -> i % 2 == 0)
    .peek(i -> System.out.println("filtered: " + i))
    .limit(3)
    .forEach(i -> System.out.println("result: " + i));

import java.util.Arrays;

public class Task180226 {
    public static void main(String[] args) {
        int[] arr1 = {1, 2, 3};
        int[] arr2 = {1, 2, 3};
        int[] arr3 = arr1;

        arr3[0] = 10;

        System.out.println(arr1 == arr2);
        System.out.println(arr1.equals(arr2));
        System.out.println(Arrays.equals(arr1, arr2));
        System.out.println(arr1[0] + " " + arr2[0] + " " + arr3[0]);
    }
}