1Z0-829 Practice Test 18 — 15 Questions

Question 1

What is the result of executing this code?

Accepted Answer

Runtime exception. Option C is correct. Collectors.toUnmodifiableList returns an immutable list, so calling add throws UnsupportedOperationException at runtime. Option A is wrong because the code compiles. Options B and D are wrong because the add operation fails.

Answer

Compilation error

Answer

[b]

Answer

[b, d]

Question 2

A developer is designing a method that returns an immutable list of strings from an array. Which approach best follows current Java best practices?

Accepted Answer

Return List.of(array). Option A is correct because List.of returns an immutable list, introduced in Java 9, and rejects nulls, making it the best practice. Option B returns a fixed-size list that is mutable via set() and allows nulls, so it is not immutable. Option C works but is verbose and still allows nulls; List.of is preferred. Option D returns a mutable list.

Answer

Return new ArrayList<>(Arrays.asList(array))

Answer

Return Collections.unmodifiableList(Arrays.asList(array))

Answer

Return Arrays.asList(array)

Question 3

Which TWO statements correctly use the DateTimeFormatter class? (Choose two.)

Accepted Answer

DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);. Option A is correct because DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL) uses the default locale. Option C is correct because ofPattern uses standard pattern letters. Option B is wrong because ISO_LOCAL_DATE is a predefined formatter, not a pattern. Option D is wrong because ofLocalizedTime uses FormatStyle, not Locale as first argument. Option E is wrong because ofPattern does not take a Locale as second argument in that order.

Answer

DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE.ofPattern("yyyy-MM-dd");

Answer

DateTimeFormatter formatter = DateTimeFormatter.ofPattern(Locale.US, "yyyy-MM-dd");

Answer

DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedTime(Locale.US, FormatStyle.MEDIUM);

Question 4

What is the output of the code in the exhibit?

Accepted Answer

1.234,57 €. Option B is correct. In Germany, the currency symbol is €, and the format uses comma as decimal separator and dot as group separator, resulting in '1.234,57 €'. Option A uses wrong symbol and grouping. Option C uses wrong decimal separator. Option D is a different locale format.

Answer

1,234.57 €

Answer

€1,234.57

Answer

€ 1.234,57

Question 5

Which two statements about multi-catch blocks are correct?

Accepted Answer

A multi-catch block can be used with a finally block.. Option B is correct because the exception types in a multi-catch block must be disjoint (no subtype relationship). Option D is correct because a multi-catch block can be combined with a finally block. Option A is wrong because multi-catch can catch both checked and unchecked exceptions. Option C is wrong because the variable in a multi-catch block is implicitly final. Option E is wrong because multi-catch can be used with any try, not only try-with-resources.

Answer

A multi-catch block cannot catch both checked and unchecked exceptions.

Answer

The variable in a multi-catch block is not implicitly final.

Answer

A multi-catch block can only be used with try-with-resources.

Question 6

A financial trading application uses Java 17 and processes millions of transactions per second. It uses a custom checked exception `TradeException extends Exception` for business rule violations. Recently, the transaction processing service began throwing a `RuntimeException` that wraps a `TradeException`, but the error logs only show the wrapper's message and stack trace, missing the original `TradeException` details. The logging framework prints the exception and its cause chain. The development team needs to ensure that the original `TradeException` message and stack trace are always logged. What is the most appropriate course of action?

Accepted Answer

Modify the exception wrapping code to pass the original TradeException as a cause to the RuntimeException constructor.. Option C is correct because the issue is that the wrapping code does not pass the original exception as a cause. By using the `RuntimeException(Throwable cause)` constructor or `RuntimeException(String message, Throwable cause)`, the original exception is preserved in the cause chain, and the logging framework will include it. Option A is a workaround but not a proper fix and could be error-prone. Option B changes the exception type but does not address the missing cause, and may break checked exception contracts. Option D is irrelevant because the wrapper's `getMessage()` is the one being logged, not the original.

Answer

Catch the RuntimeException in the main processing loop and print the cause's message using getCause().getMessage().

Answer

Modify the TradeException class to extend RuntimeException.

Answer

Override the getMessage() method in TradeException to return the original message.

Question 7

A developer needs to read a large text file (several gigabytes) line by line as efficiently as possible, processing each line without loading the entire file into memory. Which approach should the developer use?

Accepted Answer

Use Files.lines with a try-with-resources block, and process each line using the stream.. Files.lines returns a Stream<String> that reads lines lazily from the file, allowing processing without loading the whole file into memory. Using try-with-resources ensures the stream is closed properly. Option A (FileReader wrapped in BufferedReader) also reads line by line but requires manual resource management to avoid leaks; while correct, it is not the most idiomatic and concise approach. Option C (FileInputStream) reads raw bytes. Option D (Files.readAllLines) reads all lines into the memory, causing out-of-memory for large files.

Answer

Use a FileReader wrapped in a BufferedReader, and process each line in a loop.

Answer

Use a FileInputStream to read bytes, then manually parse newline characters.

Answer

Use Files.readAllLines to read the entire file into a List<String> and then iterate.

Question 8

Which TWO are secure coding practices for Java I/O that help prevent resource leaks and unauthorized access? (Choose two.)

Accepted Answer

Mark sensitive fields in a Serializable class as transient to prevent serialization.. Using try-with-resources ensures that all resources are closed automatically, preventing resource leaks. Marking sensitive fields as transient prevents their serialization. Option C (using Scanner) is not inherently secure; Option D (BufferedReader) is fine but not specifically a security practice; Option E (FilePermission) is a security policy, not a coding practice.

Answer

Use Scanner instead of BufferedReader when reading untrusted input.

Answer

Always use BufferedReader for reading text files to improve performance.

Answer

Grant FilePermission in the security policy to restrict file access for untrusted code.

Question 9

A class that stores sensitive user data implements Serializable. To minimize security exposure from deserialization attacks, which modification is the best practice?

Accepted Answer

Declare the sensitive fields as transient.. Marking sensitive fields as transient prevents them from being serialized, so they are not exposed in the serialized stream. Option B (implement writeObject) can be used but does not inherently prevent serialization of fields. Option C (remove implements Serializable) may break other functionality if serialization is needed. Option D (use Externalizable) allows custom control but still requires careful handling.

Answer

Override writeObject to manually exclude the sensitive fields.

Answer

Implement Externalizable and override readExternal and writeExternal.

Answer

Remove the implements Serializable clause from the class declaration.

Question 10

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?

Accepted Answer

Wrap the Files.lines call in a try-with-resources block to ensure the stream is closed automatically.. The 'Too many open files' error indicates that the file handle from Files.lines is not being closed, causing a resource leak. Using try-with-resources ensures the stream is closed after processing. Option A (BufferedReader) also requires try-with-resources to avoid leaks, and if not used, would have the same issue. Option C (InputStream) would not handle lines. Option D (Files.readAllLines) would cause memory issues.

Answer

Use FileInputStream with a buffered byte array and manually scan for newline characters.

Answer

Replace Files.lines with Files.newBufferedReader, wrapping it in a try-with-resources block.

Answer

Use Files.readAllLines to load the entire file into memory and then iterate over the list.

Question 11

Refer to the exhibit. A Java application is deployed in /opt/app/lib/ and attempts to perform the following operations:
1) Read the file /data/config/settings.xml
2) Write to the file /logs/app.log
3) Read the file /data/config/subdir/extra.conf
Which statement is true?

Accepted Answer

Operations 1 and 2 are allowed; operation 3 is denied.. The grant applies to code from /opt/app/lib/* (all jars in that directory). The first FilePermission "/data/config/*" grants read access to /data/config/settings.xml but not to /data/config/subdir/extra.conf because * only matches files in the directory, not subdirectories. The second permission grants write to /logs/app.log exactly. So only operations 1 and 2 are allowed.

Answer

All three operations are allowed because the code base matches.

Answer

Only operation 1 is allowed; operations 2 and 3 are denied.

Answer

Operations 1 and 3 are allowed; operation 2 is denied.

Question 12

Which statement about the code is correct?

Accepted Answer

A compilation error occurs in the Triangle class because Triangle is not listed in the permits clause.. The Triangle class is not listed in the permits clause of Shape, so it cannot extend Shape. This causes a compilation error.

Answer

A compilation error occurs because Circle must be declared final.

Answer

A compilation error occurs because Shape must be declared abstract.

Answer

The code compiles successfully.

Question 13

Which two statements are true about records in Java? (Choose two.)

Accepted Answer

Records provide a canonical constructor that initializes all components.. Records are implicitly final and provide a canonical constructor that initializes all components. They cannot extend other classes, cannot have instance fields outside the component list, and cannot be abstract.

Answer

Records can be abstract.

Answer

Records can extend other classes.

Answer

Records can have instance fields that are not part of the record component list.

Question 14

You are designing a logging framework for a distributed application. The framework must support multiple output destinations (console, file, network socket) and allow clients to dynamically add new destinations at runtime without modifying existing code. Currently, the application uses a single static Logger class with methods like logToConsole(String msg) and logToFile(String msg). The team needs to refactor the code to adhere to the Open/Closed Principle and support extensibility. After reviewing the requirements, you propose using a combination of an interface and a strategy pattern. However, a senior developer argues that using a simple enum with abstract methods would be sufficient. Which course of action best adheres to object-oriented design principles and allows the most flexibility for future extensions?

Accepted Answer

Refactor Logger to be an interface, and implement concrete destination classes (ConsoleLogger, FileLogger, SocketLogger). Use dependency injection to pass the desired destination to the Logger client.. Option A uses an interface and dependency injection, which allows new destinations to be added without modifying existing code, fully adhering to the Open/Closed Principle. Option B (enum) requires modifying the enum to add new destinations, violating Open/Closed. Option C (adding methods) also requires modification. Option D (abstract class with subclasses) still requires a factory modification. Therefore, A is the best.

Answer

Keep the existing static methods but add a new method for each destination as needed. Use conditional logic to select the destination at runtime.

Answer

Create an enum LogDestination with values CONSOLE, FILE, SOCKET, each overriding an abstract log(String) method. The Logger class uses a static method that accepts a LogDestination and calls its log method.

Answer

Refactor Logger to be an abstract class with an abstract log method, and create subclasses for each destination. Use a factory method to instantiate the correct subclass.

Question 15

A company has a legacy application consisting of multiple JAR files that run on Java 11. They plan to migrate to Java 17 and modularize the application using JPMS. However, some third-party libraries do not provide module-info.class files. What is the best approach to ensure the application can be modularized while maintaining compatibility with these libraries?

Accepted Answer

Create a module-info.java for the application that requires all third-party libraries as automatic modules.. Option B is correct because creating a module-info.java that requires the third-party libraries as automatic modules (by placing them on the module path) allows the application to be modular while using libraries without module-info. Option A is wrong because mixing classpath and module path can lead to class-loading inconsistencies and is not recommended. Option C is wrong because using --add-reads and --add-exports for all libraries is verbose and error-prone. Option D is wrong because jlink creates a runtime image but does not solve the modularization of dependencies.

Answer

Place all third-party JARs on the classpath and the application JARs on the module path.

Answer

Place all JARs on the module path and use the --add-reads and --add-exports flags to resolve dependencies.

Answer

Use the jlink tool to create a custom runtime image that includes all needed modules.

1Z0-829 Practice Test 18 — 15 Questions

Exhibit

1Z0-829 Practice Test 18 — 15 Questions

Exhibit