import java.util.Optional;

public class Task100226 {
    public static void main(String[] args) {
        Optional<String> opt = Optional.ofNullable(null)
            .map(s -> s.toString())
            .or(() -> Optional.of("DEFAULT"))
            .filter(s -> s.length() > 3);
        
        System.out.println(opt.orElse("FALLBACK"));
    }
}

import java.util.Objects;

public class SafeStringComparison {
    public static void main(String[] args) {
        String constantValue = "EXPECTED_VALUE";
        String variableFromExternalSource = getPossiblyNullString(); // Может вернуть null

        //Антипаттерн: Риск NullPointerException.
        try {
            boolean unsafeResult = variableFromExternalSource.equals(constantValue);
        } catch (NullPointerException e) {
            System.out.println("NPE: Прямой вызов equals на null-переменной.");
        }

        //Решение 1: Вызов equals() на строковой константе.
        boolean safeResult1 = constantValue.equals(variableFromExternalSource);
        System.out.println("Сравнение через константу: " + safeResult1); // Безопасно вернет false.

        //Решение 2: Использование Objects.equals().
        boolean safeResult2 = Objects.equals(constantValue, variableFromExternalSource);
        System.out.println("Сравнение через Objects.equals(): " + safeResult2); // Также безопасно.

        // Пример с двумя null-значениями:
        String nullString = null;
        boolean resultForTwoNulls = Objects.equals(nullString, null); // Возвращает true.
        System.out.println("Objects.equals(null, null): " + resultForTwoNulls);
    }

    private static String getPossiblyNullString() {
        // Имитация логики, которая может вернуть null.
        return Math.random() > 0.5 ? "SOME_VALUE" : null;
    }
}

import java.util.*;

public class Task110226 {
    public static void main(String[] args) {
        String str = null;
        List<String> list = new ArrayList<>();
        
        System.out.println(str == null);
        System.out.println("null".equals(str));
        System.out.println(Objects.equals(str, "test"));
        System.out.println(list.equals(str));
    }
}

Stream<Book> stream = library.getBooks().stream()
    .filter(b -> b.year() > 1950);

System.out.println("Stream создан");
System.out.println("Количество элементов: ???");  // Как узнать? Нельзя.

// ArrayList: SIZED, ORDERED, SUBSIZED — оптимальные характеристики
List<Book> arrayList = new ArrayList<>();
Stream<Book> stream1 = arrayList.stream();

// LinkedList: только ORDERED — менее информативный Spliterator
List<Book> linkedList = new LinkedList<>();
Stream<Book> stream2 = linkedList.stream();

// Без боксинга — прямая работа с int[]
int[] years = {1950, 1961, 1984, 2001};
IntStream yearStream = Arrays.stream(years);

// С боксином — Stream<Integer>, менее эффективен
Stream<Integer> boxedStream = Arrays.stream(years).boxed();

// Бесконечная последовательность: 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
        }
    }
}