1Z0-829 Java I/O API and Securing Applications — Timed 30 Questions

Question 1

Which TWO approaches are valid for writing text data to a file in Java? (Choose two.)

Accepted Answer

new FileWriter("out.txt", true).write(text). Valid because FileWriter with append mode and write(String) writes text directly. Option D is valid because PrintWriter has a constructor that accepts a filename string, and print() writes text to the file. Option A writes bytes without considering character encoding, option B uses writeUTF which is not for plain text files, and option E writes a collection of lines, not a single text string directly.

Answer

new FileOutputStream("out.txt").write(text.getBytes())

Answer

new RandomAccessFile("out.txt", "rw").writeUTF(text)

Answer

Files.write(Paths.get("out.txt"), lines, StandardOpenOption.CREATE)

Question 2

A developer is tasked with reading a large binary file (1 GB) from a network share using the least amount of memory possible. Which approach should be used?

Accepted Answer

Use a FileInputStream wrapped in a BufferedInputStream with a 8 KB buffer. Using a FileInputStream wrapped in a BufferedInputStream with a small buffer (e.g., 8 KB) allows reading the file in chunks without loading the entire 1 GB into memory. This approach minimizes heap usage by processing data incrementally, which is essential for large binary files over a network share where memory constraints are critical.

Answer

Read the entire file into a byte array using Files.readAllBytes()

Answer

Use a FileReader wrapped in a BufferedReader to read lines

Answer

Use a RandomAccessFile to read the file in segments

Question 3

A Java application writes sensitive user data to a file. To ensure that data is not left in the file system after the application crashes, which practice should be followed?

Accepted Answer

Write to a temporary file, then use Files.move() with ATOMIC_MOVE to replace the target file. Writing to a temporary file and then atomically moving it with `Files.move()` using the `ATOMIC_MOVE` option ensures that the target file is replaced only after the write succeeds. If the application crashes during the write, only the temporary file is corrupted, and the original target file remains intact. This prevents sensitive data from being left in an incomplete or partially written state in the file system.

Answer

Call flush() after every write operation

Answer

Delete the file manually in a finally block

Answer

Use a FileLock to prevent concurrent access

Question 4

An application must read a configuration file that is updated frequently by another process. The developer wants to avoid stale data and minimize I/O operations. Which approach is best?

Accepted Answer

Use java.nio.file.WatchService to monitor the file for modifications and reload when notified. Java.nio.file.WatchService provides an event-driven mechanism to monitor file system changes, such as modifications to a configuration file. This approach avoids stale data by reloading the file only when a change is detected, and it minimizes I/O operations by eliminating the need for polling or repeated reads. The WatchService uses the underlying OS file system events (e.g., inotify on Linux, ReadDirectoryChanges on Windows) for efficient notification.

Answer

Read the file from disk every time it is accessed using Files.newInputStream()

Answer

Periodically check the file's lastModified timestamp using File.lastModified() and reload if changed

Answer

Read the file once at startup and cache the content in memory

Question 5

A developer needs to write text to a file with UTF-8 encoding. Which class should be used?

Accepted Answer

new OutputStreamWriter(new FileOutputStream(file), StandardCharsets.UTF_8). It explicitly constructs an OutputStreamWriter with a FileOutputStream and StandardCharsets.UTF_8, ensuring the text is written with UTF-8 encoding. This is the standard approach when you need precise control over the character encoding, as the OutputStreamWriter acts as a bridge from byte streams to character streams using the specified charset.

Answer

BufferedWriter

Answer

FileWriter

Answer

PrintWriter with default constructor

Question 6

A Java application running in a secure environment needs to read a file located outside the application's directory. Which approach correctly handles security?

Accepted Answer

Grant java.io.FilePermission in the security policy file for the specific file path. In a secure Java environment, the SecurityManager enforces access controls based on the security policy file. To read a file outside the application's directory, you must explicitly grant `java.io.FilePermission` with the specific file path and the `read` action in the policy file. Without this permission, any attempt to read the file will throw a `java.security.AccessControlException`.

Answer

Use FileInputStream without any additional configuration

Answer

Use java.net.URL to access the file via file:// protocol

Answer

Set the file readable flag using File.setReadable(true)

Question 7

A developer is designing a service that processes multiple files concurrently. To avoid resource leaks, which practice is essential?

Accepted Answer

Use try-with-resources for each AutoCloseable resource. Try-with-resources guarantees that each AutoCloseable resource is closed automatically at the end of the statement, even if an exception occurs. This is essential when processing multiple files concurrently, as it prevents resource leaks without requiring explicit close() calls in finally blocks.

Answer

Ensure each thread has its own copy of the file handle

Answer

Call close() on each stream in a separate try-catch block

Answer

Use FileLock to prevent concurrent access

Question 8

Which statement about java.io and java.nio.file packages is true?

Accepted Answer

The java.nio.file package provides support for symbolic links and file attributes. The java.nio.file package (part of NIO.2) explicitly provides support for symbolic links via methods like Files.createSymbolicLink() and Files.isSymbolicLink(), and it offers comprehensive file attribute access through classes like BasicFileAttributes, DosFileAttributes, and PosixFileAttributes, which are not available in java.io.

Answer

Classes in java.nio.file are thread-safe by default

Answer

The java.io package includes the Path interface

Answer

The java.nio.file package is deprecated in favor of java.io

Question 9

A developer needs to copy a large directory tree from one location to another, preserving file attributes. Which method should be used?

Accepted Answer

Implement a FileVisitor using Files.walkFileTree and copy each file with COPY_ATTRIBUTES. `Files.walkFileTree` with a custom `FileVisitor` allows you to recursively traverse a directory tree and copy each file individually using `Files.copy` with `StandardCopyOption.COPY_ATTRIBUTES`. This is necessary because `Files.copy` on a directory does not copy the directory tree recursively; it only copies the top-level directory entry. The `FileVisitor` pattern ensures that subdirectories and files are visited and copied in depth-first order, preserving file attributes at each step.

Answer

Files.copy(source, target, StandardCopyOption.COPY_ATTRIBUTES)

Answer

Use Files.walk() and then Files.copy() for each entry

Answer

Use FileUtils.copyDirectory from Apache Commons IO

Question 10

Which TWO statements are true about securing a Java application?

Accepted Answer

A security policy file can grant specific permissions to code from a particular codebase.. A Java security policy file can use a codebase URL (e.g., `codeBase "file:/path/to/jar"`) to grant specific permissions, such as `java.io.FilePermission`, to code loaded from that location. This is a core feature of the Java security model, allowing fine-grained access control based on where the code originates.

Answer

Enabling the security manager is required for all Java applications.

Answer

The Java Cryptography Extension (JCE) is deprecated and should not be used.

Answer

Using code signing guarantees that the application is secure.

Question 11

Which THREE are valid ways to read the contents of a text file into a String in Java?

Accepted Answer

String content = Files.readString(Path.of("file.txt"));. `Files.readString()` (introduced in Java 11) reads the entire content of a text file into a `String` in one call, handling charset encoding (default UTF-8) and closing the file automatically. It is the simplest and most direct method for this task.

Answer

String content = new FileReader("file.txt").readString();

Answer

String content = Files.readAllLines(Path.of("file.txt"));

Question 12

Which TWO are true about the try-with-resources statement?

Accepted Answer

Resources declared outside the try block can be used if they are effectively final.. The try-with-resources statement allows resources declared outside the try block to be used, provided they are effectively final (i.e., their reference does not change after initialization). This was introduced in Java 9, which enhanced try-with-resources to support effectively final variables in addition to those declared directly within the try parentheses.

Answer

All resources must be of the same type.

Answer

Multiple resources must be separated by commas.

Answer

The resource must implement the Closeable interface.

Question 13

Which THREE are benefits of using the NIO.2 API over the java.io API?

Accepted Answer

Simplified recursive file operations using FileVisitor.. The NIO.2 API introduces the `FileVisitor` interface, which simplifies recursive file operations by allowing you to implement methods like `preVisitDirectory`, `visitFile`, and `visitFileFailed` that are automatically called during a tree walk. This eliminates the need for manual recursion and boilerplate code required in the `java.io` API, making directory traversal more efficient and less error-prone.

Answer

Better performance for all I/O operations compared to java.io.

Answer

Automatic file compression when writing.

Question 14

A financial trading application processes real-time stock data from multiple exchanges. The application reads large binary files (each up to 500 MB) containing trade records, processes them, and writes summary reports to a shared network drive. The development team observes that the application occasionally throws a java.io.IOException: 'The process cannot access the file because it is being used by another process' when writing reports. The application is multi-threaded, and each thread writes to a separate file in the same directory. The team also notices that the application slows down significantly when the network drive is under heavy load. The application runs on Windows servers with Java 17. The code uses FileOutputStream for writing and does not explicitly close streams in some paths. Which course of action should the team take to resolve the issues and improve performance?

Accepted Answer

Switch to using try-with-resources for all FileOutputStream instances and wrap them in BufferedOutputStream with a larger buffer.. The primary issue is resource leaks from not closing FileOutputStream instances, which can cause file locking conflicts on Windows when multiple threads write to separate files in the same directory. Using try-with-resources ensures streams are closed reliably, eliminating the 'file in use' IOException. Wrapping with BufferedOutputStream and a larger buffer reduces the number of write operations to the network drive, mitigating slowdowns under heavy load by batching data and minimizing latency.

Answer

Increase the thread pool size to handle more concurrent writes.

Answer

Use FileChannel with FileLock to synchronize access.

Answer

Write to local temporary files and then copy to the network drive.

Question 15

A Java application reads configuration from a file using FileInputStream. The application must handle the case where the configuration file is missing by logging a warning and using default values. Which design approach best meets this requirement?

Accepted Answer

Use Files.exists() to check file existence before opening the stream, and if absent, log a warning and use defaults.. It explicitly checks for file existence using `Files.exists()` before attempting to open the stream, allowing the application to log a warning and fall back to default values without throwing an exception. This approach aligns with the requirement to handle a missing configuration file gracefully, avoiding unnecessary exception handling overhead. The `Files.exists()` method is part of the modern `java.nio.file` API, which is preferred over the legacy `File.exists()` for its better integration with symbolic links and file system operations.

Answer

Wrap the FileInputStream in a try-with-resources and catch Exception to handle missing file.

Answer

Catch FileNotFoundException inside the try block and set default values.

Answer

Use File.exists() to check file existence before opening the stream, and if absent, log a warning and use defaults.

Question 16

Which TWO statements about Java serialization are true?

Accepted Answer

During deserialization, the constructor of the serialized class is not invoked.. During deserialization, Java does not invoke the constructor of the class being deserialized. Instead, the object is reconstructed from the serialized stream data using the no-arg constructor of the first non-serializable superclass (if any), and the serialized class's fields are populated via reflection or readObject() methods. This avoids re-executing initialization logic that may have side effects or depend on runtime state.

Answer

The serialVersionUID must be explicitly declared in every serializable class.

Answer

A class that implements Externalizable does not need to implement Serializable.

Answer

Fields marked as transient are serialized by default.

Question 17

You are developing a Java application that processes sensitive user data. The application runs on a server with strict security policies. You need to read configuration properties from a file located at /etc/app/config.properties. The application uses a SecurityManager. During testing, you get a security exception: java.security.AccessControlException: access denied (java.io.FilePermission /etc/app/config.properties read). You have already added a file permission grant in the policy file for the application codebase. However, the exception persists. What is the most likely cause?

Accepted Answer

A library or caller on the execution stack does not have the required FilePermission.. Even if the application's own codebase has the required FilePermission, any library or caller on the execution stack that does not have the permission will cause an AccessControlException. The SecurityManager performs stack inspection: every class on the call stack must have the required permission. If a library or framework method invoked by your code lacks the grant, the check fails.

Answer

The application codebase URL in the policy file is incorrect.

Answer

The file path is relative and needs to be resolved against user.dir.

Answer

The policy file is not being loaded because the JVM was not started with -Djava.security.policy.

Question 18

Which TWO statements about java.io and java.nio.file packages are true?

Accepted Answer

java.nio.file.Files class provides methods for operating on symbolic links.. The `java.nio.file.Files` class provides methods such as `createSymbolicLink()`, `readSymbolicLink()`, and `isSymbolicLink()` that directly operate on symbolic links in the file system. This is a key feature of the NIO.2 API, which offers comprehensive support for file system metadata and link management, unlike the older `java.io` package.

Answer

java.io.Console can be used to read from and write to the standard streams of the JVM.

Answer

java.io.FileInputStream supports the mark and reset methods.

Answer

java.nio.file.Path is a class that represents a file path.

Question 19

A Java application running on a server reads configuration from a file 'config.properties' located in the same directory as the JAR. The application uses java.util.Properties.load(InputStream) to read the file. Recently, the file was modified by an unauthorized user, and the application started throwing runtime exceptions due to corrupted property values. The security team requires that the file be protected from unauthorized modifications while still being readable by the application. Which action should be taken to ensure the integrity of the configuration file?

Accepted Answer

Digitally sign the file and verify the signature before loading properties.. Digital signing provides both integrity and authenticity. By signing the file with a private key and verifying the signature with a public key before calling Properties.load(InputStream), the application can detect any unauthorized modification. This directly addresses the security requirement without relying on encryption (which protects confidentiality, not integrity) or file permissions (which can be bypassed by a privileged attacker).

Answer

Encrypt the file using AES and decrypt it in the application.

Answer

Set the file permissions to read-only for the application user.

Answer

Store the file in a ZIP archive with a checksum.

Question 20

Order the steps to create an immutable class in Java.

Accepted Answer

Step 1: Declare the class as final. Step 2: Declare all fields as private and final. Step 3: Provide a constructor that initializes all fields (with defensive copying for mutable fields). Step 4: Do not define any setter methods.. Immutability requires no way to change object state after construction. Defensive copying prevents internal state from being altered.

Answer

Step 1: Declare all fields as private and final. Step 2: Provide a constructor that initializes all fields. Step 3: Declare the class as final. Step 4: Do not define any setter methods.

Answer

Step 1: Provide a constructor that initializes all fields. Step 2: Declare all fields as private and final. Step 3: Declare the class as final. Step 4: Do not define any setter methods.

Answer

Step 1: Do not define any setter methods. Step 2: Declare the class as final. Step 3: Declare all fields as private and final. Step 4: Provide a constructor that initializes all fields.