// Базовое использование с автоматическим закрытием
try (Stream<String> lines = Files.lines(Path.of("access.log"))) {
    long errorCount = lines
        .filter(line -> line.contains("ERROR"))
        .count();
}

// Фильтрация, трансформация, запись результата — всё в потоковом режиме
try (Stream<String> lines = Files.lines(Path.of("huge_input.txt"));
     BufferedWriter writer = Files.newBufferedWriter(Path.of("filtered_output.txt"))) {
    
    lines.parallel()  // Осторожно: см. предупреждение ниже
        .filter(line -> line.length() > 100)
        .map(String::toUpperCase)
        .map(line -> line + System.lineSeparator())
        .forEachOrdered(line -> {
            try {
                writer.write(line);
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        });
}

// Кастомная кодировка и буфер
try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(
            new FileInputStream("legacy.txt"), 
            StandardCharsets.ISO_8859_1
        ), 
        16384  // Удвоенный буфер для последовательного чтения
    );
    Stream<String> lines = reader.lines()) {
    
    lines.map(this::parseLegacyRecord)
         .filter(Objects::nonNull)
         .forEach(this::processRecord);
}

// Проблема: readLine бросает IOException
Stream<String> lines = Files.lines(path);
lines.map(line -> {
    // Ошибка компиляции: unreported exception IOException
    return expensiveParser.parse(line);  
});

.lines.map(line -> {
    try {
        return expensiveParser.parse(line);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
})

private ParsedRecord safeParse(String line) {
    try {
        return expensiveParser.parse(line);
    } catch (IOException e) {
        throw new UncheckedIOException(e);
    }
}

// В потоке
.lines.map(this::safeParse)

// КАТАСТРОФА: параллельное чтение файла через common pool
try (Stream<String> lines = Files.lines(Path.of("access.log"))) {
    lines.parallel()  // Нет выигрыша, есть риск
        .map(this::blockingDatabaseLookup)  // Блокировка воркера
        .collect(toList());
}

// Чтение последовательное, обработка параллельная — но с осторожностью
List<String> batch = new ArrayList<>(BATCH_SIZE);
try (Stream<String> lines = Files.lines(Path.of("huge.txt"))) {
    lines.forEach(line -> {
        batch.add(line);
        if (batch.size() >= BATCH_SIZE) {
            processBatchParallel(new ArrayList<>(batch));  // Копия для безопасности
            batch.clear();
        }
    });
    if (!batch.isEmpty()) processBatchParallel(batch);
}

private void processBatchParallel(List<String> batch) {
    batch.parallelStream()
        .map(this::expensiveCpuBoundTransform)
        .collect(toList());  // Результат куда-то сохраняется
}

// Правильно: изолированный пул для блокирующих операций
ExecutorService ioPool = Executors.newFixedThreadPool(50);

try (Stream<String> lines = Files.lines(Path.of("urls.txt"))) {
    List<CompletableFuture<Response>> futures = lines
        .map(url -> CompletableFuture.supplyAsync(
            () -> fetchHttp(url), 
            ioPool
        ))
        .collect(toList());
    
    List<Response> results = futures.stream()
        .map(CompletableFuture::join)
        .collect(toList());
} finally {
    ioPool.shutdown();
}

// Извлечение из CSV
try (Stream<String> lines = Files.lines(Path.of("input.csv"));
     // Загрузка в выходной файл
     BufferedWriter writer = Files.newBufferedWriter(Path.of("output.json"))) {
    
    lines.skip(1)  // Пропуск заголовка
        .map(this::parseCsvLine)           // String -> Record
        .filter(Objects::nonNull)            // Удаление malformed
        .map(this::transformToJson)          // Record -> JSON string
        .forEach(json -> {
            try {
                writer.write(json);
                writer.newLine();
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        });
}

try (Stream<String> lines = Files.lines(Path.of("corrupt.txt"))) {
    lines.map(this::parse)
        .filter(Objects::nonNull)
        .forEach(this::process);
    // Если parse бросает RuntimeException на 1000-й строке,
    // lines.close() вызывается автоматически
}

// Антипаттерн: ресурс внутри map
lines.map(line -> {
    Connection conn = pool.borrow();  // Открытие здесь
    return query(conn, line);         // Если исключение, conn не возвращается
})

// Правильно: try-with-resources внутри лямбды, или вне потока

import java.io.*;

public class Task060426 {
    public static void main(String[] args) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        DataOutputStream dos = new DataOutputStream(baos);
        dos.writeInt(255);
        dos.flush();

        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        DataInputStream dis = new DataInputStream(bais);
        
        int value = dis.read();
        System.out.println(value);
    }
}

import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;

public class ParallelStreamTimeout {
    
    //Антипаттерн: parallelStream без контроля тайм-аута
    public static List<Integer> dangerousParallel() {
        List<Integer> numbers = IntStream.range(0, 10).boxed().collect(Collectors.toList());
        
        return numbers.parallelStream()
            .map(n -> {
                // Представьте, что здесь долгий внешний вызов
                try { Thread.sleep(100_000); } catch (InterruptedException e) {}
                return n * 2;
            })
            .collect(Collectors.toList());
        // Зависнет навсегда, общий pool заблокирован
    }
    
    //Решение: явный ExecutorService с тайм-аутом
    public static List<Integer> safeWithExecutor(List<Integer> numbers) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        List<Future<Integer>> futures = numbers.stream()
            .map(n -> executor.submit(() -> {
                // Симуляция долгой операции
                Thread.sleep(100); // реальная логика
                return n * 2;
            }))
            .collect(Collectors.toList());
        
        List<Integer> result = new ArrayList<>();
        for (Future<Integer> future : futures) {
            try {
                // Тайм-аут 1 секунда на задачу
                result.add(future.get(1, TimeUnit.SECONDS));
            } catch (TimeoutException e) {
                future.cancel(true); // Попытка прервать
                result.add(null); // или обработка ошибки
                System.err.println("Задача не уложилась в тайм-аут");
            } catch (ExecutionException e) {
                throw new RuntimeException(e.getCause());
            }
        }
        executor.shutdown();
        return result;
    }
    
    //Альтернатива: CompletableFuture с тайм-аутом (Java 9+)
    public static CompletableFuture<List<Integer>> asyncWithTimeout(List<Integer> numbers) {
        List<CompletableFuture<Integer>> futures = numbers.stream()
            .map(n -> CompletableFuture.supplyAsync(() -> {
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                return n * 2;
            }).orTimeout(500, TimeUnit.MILLISECONDS)  // Тайм-аут 500 мс
              .exceptionally(ex -> {
                  System.err.println("Ошибка или тайм-аут: " + ex.getMessage());