1Z0-829 Java I/O API and Securing Applications Practice Question
A developer is building a batch processing application that reads a large CSV file (approx. 5 GB) from a network file system, transforms each row, and writes the result to a database. The initial implementation uses Files.lines(path) to obtain a Stream<String>, processes each line with forEach, and then does not explicitly close the stream. After running for several minutes, the application slows down, and eventually throws an IOException: 'Too many open files'. The database writes are also failing intermittently. The developer needs to fix the application. The environment is Java 17 on Linux with default settings. Which course of action best resolves the issues?
⚠ Common exam trap
The trap here is that candidates often overlook that `Files.lines` returns a stream that must be closed, confusing it with in-memory collections like `List` that do not hold system resources, or incorrectly assuming that `forEach` terminal operation automatically closes the stream.
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Wrap the Files.lines call in a try-with-resources block to ensure the stream is closed automatically.
`Files.lines(path)` returns a lazily populated `Stream<String>` that holds a file handle open. Without an explicit close, the underlying `FileChannel` and file descriptor are not released, leading to 'Too many open files' after processing many lines. Wrapping the stream in a try-with-resources block ensures `close()` is called automatically, releasing the file descriptor and preventing resource exhaustion.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
Use FileInputStream with a buffered byte array and manually scan for newline characters.
Why it's wrong here
This is low-level, error-prone, and does not solve the resource leak issue unless the stream is also properly closed. It introduces unnecessary complexity.
- ✗
Replace Files.lines with Files.newBufferedReader, wrapping it in a try-with-resources block.
Why it's wrong here
This would also work but is not the best because Files.lines is more idiomatic for line-by-line streaming. However, the key issue is the missing closure; both approaches need try-with-resources. This option is plausible but not the best given that the original code used Files.lines.
- ✗
Use Files.readAllLines to load the entire file into memory and then iterate over the list.
Why it's wrong here
This would cause OutOfMemoryError for a 5 GB file, making the problem worse.
- ✓
Wrap the Files.lines call in a try-with-resources block to ensure the stream is closed automatically.
Why this is correct
By using try-with-resources, the stream's underlying file handle is closed when the block exits, fixing the resource leak. This is the minimal and correct fix.
Visual reference
Go deeper
Related to this question
About these practice questions
This 1Z0-829 question is part of Courseiva's 513-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. Learn why practice questions differ from exam dumps →
JA
Written by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
This 1Z0-829 practice question is part of Courseiva's free Oracle certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the 1Z0-829 exam.