// Базовое использование с автоматическим закрытием
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);
    }
}