1Z0-829 Practice Test 2 — 25 Questions

Question 1

Which TWO are valid ways to create an immutable List in Java?

Accepted Answer

Collections.unmodifiableList(new ArrayList<>()). `Collections.unmodifiableList()` returns a view of the specified list that cannot be structurally modified; any attempt to add, remove, or set elements will throw an `UnsupportedOperationException`. Option E is correct because `List.of()` (introduced in Java 9) directly creates an immutable list that disallows `null` elements and throws `UnsupportedOperationException` on mutation attempts.

Answer

Stream.of("a").collect(Collectors.toList())

Answer

Arrays.asList("a", "b")

Answer

new ArrayList<>()

Question 2

Which TWO statements are true about the java.time.Duration class? (Choose two.)

Accepted Answer

Duration represents a time-based amount of time, such as hours, minutes, seconds.. The java.time.Duration class models a time-based amount of time in terms of seconds and nanoseconds, which can represent hours, minutes, seconds, and smaller units. It is designed for time-based quantities, not date-based ones like days, months, or years.

Answer

Duration.ofDays(1) returns a Duration that is daylight-saving-safe.

Answer

Duration.between(LocalDate.now(), LocalDate.now().plusDays(1)) returns a Duration of 1 day.

Answer

Duration can represent a period of months.

Question 3

In a try-finally block, what happens to a return statement inside the finally block?

Accepted Answer

The return in the finally block is executed, and the try block return is ignored.. In a try-finally block, the finally block is always executed. If the finally block contains a return statement, that return value overrides any return value from the try block. Therefore, option A is correct. Option B is incorrect because the finally block always executes regardless of a return in try. Option C is incorrect because the finally return overrides the try return. Option D is incorrect because a return in finally is executed even if an exception occurs, overriding the exception.

Answer

The finally block is skipped if there is a return in try.

Answer

The return in the try block takes precedence.

Answer

If the try block throws an exception, the finally block's return is skipped.

Question 4

What is the output?

```java
int x = 10;
do {
    System.out.print(x);
} while (x-- > 10);
```

Accepted Answer

10. 10 because in the missing code, the loop condition likely uses pre-decrement or the print statement occurs before the decrement, so the first value printed is the initial value of x, which is 10. The post-decrement trap described in the current explanation does not apply.

Answer

9

Answer

15

Answer

6

Question 5

Which THREE practices are recommended for effective exception handling? (Choose three.)

Accepted Answer

Throw exceptions early, catch them late, but handle them at the appropriate level.. Effective exception handling in Java recommends throwing exceptions as soon as an error is detected (fail-fast), catching them at a level where the error can be meaningfully handled (not too early), and handling them at the appropriate layer of abstraction. This prevents swallowing exceptions or losing context, and aligns with the principle of separation of concerns.

Answer

Define custom exceptions without providing any additional context.

Answer

Catch exceptions at the highest level of the application and log them generically.

Question 6

A class implements Serializable. Which modification ensures that a specific field (password) is not included in the serialized stream?

Accepted Answer

Declare the field as transient. The `transient` modifier is the correct mechanism in Java to exclude a specific field from the default serialization process. When a class implements `Serializable`, all non-transient instance fields are serialized by default. Marking the `password` field as `transient` ensures it is skipped during serialization and restored as `null` (or default value) upon deserialization.

Answer

Declare the field as volatile

Answer

Declare the field as static

Answer

Declare the field as final

Question 7

Which interface is designed for recursively walking a file tree?

Accepted Answer

FileVisitor [CORRECT]. The `FileVisitor` interface is designed for recursively walking a file tree, as it provides callback methods (`preVisitDirectory`, `postVisitDirectory`, `visitFile`, `visitFileFailed`) that are invoked during a depth-first traversal of a file tree, typically used with `Files.walkFileTree()`. This allows you to process each file and directory in the tree, including subdirectories, making it the correct choice for recursive file tree walking.

Answer

DirectoryStream [wrong]

Answer

FilenameFilter [wrong]

Answer

FileFilter [wrong]

Question 8

Given: ZonedDateTime zdt = ZonedDateTime.of(2024, 3, 10, 2, 30, 0, 0, ZoneId.of("America/New_York")); In the US, on March 10, 2024, clocks spring forward at 2:00 AM to 3:00 AM. What is the output of System.out.println(zdt);?

Accepted Answer

2024-03-10T03:30-04:00[America/New_York]. When a ZonedDateTime is created for a time that falls within a DST gap (2:00 AM to 3:00 AM on March 10, 2024, in America/New_York), the Java API automatically adjusts the time forward to the next valid offset. The local time 2:30 AM does not exist because clocks spring forward to 3:00 AM, so the ZonedDateTime is normalized to 3:30 AM with the DST offset -04:00. This behavior is defined by the ZonedDateTime.of method, which resolves invalid local times by shifting to the offset after the gap.

Answer

Throws DateTimeException

Answer

2024-03-10T02:30-05:00[America/New_York]

Answer

2024-03-10T02:30-04:00[America/New_York]

Question 9

Given a requirement to efficiently copy a large file (over 2 GB) from one path to another, which approach is most appropriate for Java NIO.2?

Accepted Answer

Using FileChannel.transferTo() with position and count. `FileChannel.transferTo()` leverages zero-copy I/O, which allows data to be transferred directly between file system caches without unnecessary copying through user-space buffers. This is particularly efficient for large files (over 2 GB) as it minimizes context switches and memory overhead, and the method supports a `position` and `count` parameter to handle large file offsets correctly.

Answer

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

Answer

Using Files.readAllBytes() then Files.write()

Answer

Using FileInputStream and FileOutputStream with a buffer of 8192 bytes

Question 10

Which TWO of the following are checked exceptions in Java?

Accepted Answer

SQLException. A is correct because `SQLException` is a subclass of `java.lang.Exception` (which is a checked exception class) and does not extend `RuntimeException`. Checked exceptions must be either caught or declared in the method signature; `SQLException` is commonly thrown when database access errors occur, such as connection failures or SQL syntax errors.

Answer

ArithmeticException

Answer

ArrayIndexOutOfBoundsException

Answer

NullPointerException

Question 11

A serialized object has an explicitly declared serialVersionUID of 123L. After a code change, a new field is added to the class but the serialVersionUID is left unchanged. What happens when deserializing an old stream?

Accepted Answer

Deserialization succeeds and the new field is set to its default value.. When a serialized object has an unchanged serialVersionUID, the Java deserialization mechanism treats the class as compatible. The new field is not present in the old stream, so it is simply initialized to its default value (e.g., null for objects, 0 for primitives) without throwing an exception. This behavior is defined by the Java Object Serialization Specification, which allows forward compatibility as long as the serialVersionUID matches.

Answer

Deserialization succeeds only if the new field is marked transient.

Answer

Deserialization throws StreamCorruptedException due to missing field.

Answer

Deserialization throws InvalidClassException because the class definition has changed.

Question 12

Which resource declaration order in try-with-resources is valid when both a FileInputStream and a BufferedInputStream wrapping it need to be closed automatically?

Accepted Answer

try (FileInputStream fis = new FileInputStream("a"); BufferedInputStream bis = new BufferedInputStream(fis)) { ... }. In a try-with-resources statement, resources are declared in order and closed in reverse order. By declaring FileInputStream first and then BufferedInputStream wrapping it, both resources are properly closed automatically, with the BufferedInputStream closed first (ensuring its buffer is flushed) and then the FileInputStream.

Answer

try (FileInputStream fis = new FileInputStream("a")) { BufferedInputStream bis = new BufferedInputStream(fis); ... }

Answer

try (BufferedInputStream bis = new BufferedInputStream(fis); FileInputStream fis = new FileInputStream("a")) { ... }

Answer

try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a"))) { ... }

Question 13

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 14

How many times does the following loop execute? int i=0; while(i<5) { System.out.println(i); i++; }

Accepted Answer

5. The loop starts with i=0, checks the condition i<5 (true), prints i, then increments i. This repeats until i becomes 5, at which point i<5 is false and the loop terminates. Thus, the loop executes exactly 5 times (i=0,1,2,3,4).

Answer

0

Answer

6

Answer

4

Question 15

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.. Refactors Logger to be an interface and uses dependency injection, allowing clients to pass any implementation. This adheres to the Open/Closed Principle because new destinations can be added by creating new classes implementing Logger without modifying existing code. Option C (using an enum with abstract methods) violates OCP because adding a new destination requires modifying the enum. Option A (keeping static methods and adding new ones) also requires modification of the Logger class. Option D (abstract class with subclasses and factory) still requires modifying the factory when adding new destinations, reducing flexibility.

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 16

Refer to the exhibit. What is the result?

Accepted Answer

Prints 10. The code accesses the private field `x` of the `Outer` class from within the `Inner` class, which is a member inner class. In Java, a non-static inner class has access to all members (including private fields) of its enclosing outer class. The `Inner` class's `printX()` method directly accesses `Outer.this.x`, which is initialized to 10 in the `Outer` constructor, so it prints 10.

Answer

Runtime exception because Inner class is not static.

Answer

Compilation error because x is private.

Answer

Prints 0 because x is not initialized in Inner.

Question 17

A developer needs to concatenate two Stream<String> into one. Which approach is most idiomatic?

Accepted Answer

Stream.concat(stream1, stream2). `Stream.concat(stream1, stream2)` is the idiomatic, built-in static method in the Java Stream API for concatenating two streams into a single sequential stream. It creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream, preserving encounter order.

Answer

stream1.flatMap(s -> stream2)

Answer

new StreamBuilder().add(stream1).add(stream2).build()

Answer

stream1.merge(stream2)

Question 18

Which class from the java.nio.file package is most appropriate for efficiently transferring data between two channels on the same machine?

Accepted Answer

FileChannel.transferTo(long, long, WritableByteChannel). `FileChannel.transferTo()` (and its counterpart `transferFrom()`) uses the operating system's zero-copy mechanism (e.g., `sendfile()` on Linux or `TransmitFile()` on Windows) to move data directly between file system caches and the target channel without intermediate buffers or user-space copies. This makes it the most efficient approach for transferring data between two channels on the same machine, as it minimizes CPU overhead and memory bandwidth usage.

Answer

Files.copy(Path, Path)

Answer

RandomAccessFile.getChannel().write(ByteBuffer)

Answer

InputStream.transferTo(OutputStream)

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

A program reads user input as a string and needs to parse it into an integer, handling invalid input gracefully. Which code snippet correctly uses try-catch to parse and prints the result or 'Invalid number'?

Accepted Answer

try { int num = Integer.parseInt(input); System.out.println(num); } catch (NumberFormatException e) { System.out.println("Invalid number"); }. It uses `Integer.parseInt(input)` which throws a `NumberFormatException` for invalid input, and the catch block specifically catches that exception to print 'Invalid number'. This is the standard, idiomatic Java approach for parsing integers with error handling, as it directly addresses the requirement without unnecessary overhead or false positives.

Answer

try { int num = Integer.valueOf(input).intValue(); System.out.println(num); } catch (Exception e) { System.out.println("Invalid number"); }

Answer

int num = Integer.parseInt(input); System.out.println(num);

Answer

if (input.matches("\d+")) { int num = Integer.parseInt(input); System.out.println(num); } else { System.out.println("Invalid number"); }