1Z0-829 Practice Test 16 — 15 Questions

Question 1

A financial application processes transactions in batches. Each transaction is represented as a Transaction object with fields: long id, BigDecimal amount, LocalDateTime timestamp. Transactions are stored in a List<Transaction> in the order they arrive. The system needs to frequently check if a transaction with a specific id exists, and also needs to iterate through transactions in chronological order. The list currently contains millions of transactions, and the existence check is becoming a performance bottleneck because it currently uses a linear search. The system must also maintain insertion order for iteration. Which approach best improves the performance of the existence check while maintaining the required iteration order?

Choose an answer to begin — your selection is scored in the full session.

Accepted Answer

Replace List with LinkedHashMap mapping id to transaction. Iterate using values() which preserves insertion order.. LinkedHashMap maintains insertion order for iteration via its values() view, while providing O(1) key-based lookup for the existence check. This directly addresses the performance bottleneck of linear search in a List without sacrificing the required chronological iteration order.

Answer

Keep List and add a separate HashSet of ids for fast lookup. Use the list for iteration.

Answer

Keep List<Transaction> and sort it by id. Use Collections.binarySearch() for lookup.

Answer

Replace List with TreeMap mapping id to transaction. Iterate using values() which returns in natural key order.

Question 2

In the following try-with-resources block, resources are declared as: try (FileInputStream fis = new FileInputStream("data.txt"); BufferedInputStream bis = new BufferedInputStream(fis)) { ... } If an IOException occurs during the closing of both resources, which resource's close exception is returned by e.getSuppressed()?

Accepted Answer

Only the exception from FileInputStream close is in the suppressed array.. In a try-with-resources statement, resources are closed in the reverse order of their declaration. Here, FileInputStream is declared first and BufferedInputStream second, so BufferedInputStream is closed first. If both resources throw an IOException during closing, the exception from BufferedInputStream (the first to close) becomes the primary exception, and the exception from FileInputStream (the second to close) is suppressed. The primary exception is thrown from the try block, while the suppressed exception is accessible via the getSuppressed() method. Therefore, e.getSuppressed() returns an array containing the exception from FileInputStream. Option B is correct because only the FileInputStream's close exception is in the suppressed array.

Answer

The suppressed array contains both exceptions.

Answer

The suppressed array contains the exception from FileInputStream.

Answer

Only the exception from BufferedInputStream close is in the suppressed array.

Question 3

What is the output when this code is executed?

```java
int x = 2;
switch (x) {
    case 1:
        System.out.print("One ");
    case 2:
        System.out.print("Two ");
    case 3:
        System.out.print("Three ");
        break;
    default:
        System.out.print("Default");
}
```

Accepted Answer

Two Three. The switch statement matches the value 2, so it executes the case 'Two' block, which prints 'Two ' and then falls through to the next case because there is no break statement. The case 'Three' block prints 'Three ' and then breaks, exiting the switch. The default case is skipped because a matching case was found and the break in case 'Three' prevents further fall-through. Thus, the output is 'Two Three '.

Answer

Two

Answer

Two Three Default

Answer

One Two Three

Question 4

Which of the following correctly formats a NumberFormat instance to display a currency value for the US locale with exactly two decimal places, rounding half-up?

Accepted Answer

NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US); nf.setRoundingMode(RoundingMode.HALF_UP);. It uses NumberFormat.getCurrencyInstance(Locale.US) which defaults to exactly two decimal places for the US locale, and explicitly sets the rounding mode to RoundingMode.HALF_UP, satisfying both requirements. Options B and C adjust fraction digits but do not set the rounding mode, so they default to HALF_EVEN. Option D also defaults to HALF_EVEN, not HALF_UP. Therefore, only option A meets the conditions of exactly two decimal places and rounding half-up.

Answer

NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US); nf.setMinimumFractionDigits(2);

Answer

NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US); nf.setMaximumFractionDigits(2);

Answer

NumberFormat nf = NumberFormat.getCurrencyInstance(Locale.US);

Question 5

Which two of the following are valid methods to create a new directory using the NIO.2 Files class? (Select two.)

Accepted Answer

Files.createDirectory(Path). The Files class in the java.nio.file package provides two static methods for creating directories: createDirectory(Path) creates a single directory, failing if the parent does not exist or if the directory already exists; createDirectories(Path) creates the directory and any nonexistent parent directories, succeeding silently if the target already exists. Both are valid and commonly used for NIO.2 directory creation.

Answer

Files.mkdir(Path)

Answer

Files.createNewDirectory(Path)

Answer

Files.makeDirectory(Path)

Question 6

A developer writes code to iterate over a list of strings and print each element. The code uses an enhanced for loop. Which statement is true about the enhanced for loop?

Accepted Answer

It can be used with arrays and any object that implements Iterable.. The enhanced for loop (for-each) in Java can iterate over arrays and any object that implements the Iterable interface, which includes all Collection classes (e.g., List, Set, Queue). This is because the for-each loop internally uses an iterator for Iterable objects or array indexing for arrays, making it a versatile construct for traversing elements without needing an explicit counter.

Answer

It can only be used with arrays.

Answer

It requires an explicit counter variable.

Answer

It allows removing elements from the collection during iteration without ConcurrentModificationException.

Question 7

A web server application writes access logs to a file. To ensure that log entries are written to disk immediately even if the JVM crashes, which approach is most appropriate?

Accepted Answer

Use FileOutputStream and call flush() after each write.. FileOutputStream provides direct, unbuffered writes to the underlying file descriptor. While calling flush() does not force an immediate disk write (that requires sync() or FileChannel.force()), the unbuffered nature means data is passed to the operating system without intermediate caching in the JVM. Among the given options, this minimizes data loss risk because there is no JVM-level buffer that could hold unwritten data. Options B and C use buffering, which can delay writes, and D also uses an internal buffer. Note: For true guaranteed synchronous disk writes, additional system calls like FileDescriptor.sync() or FileChannel.force() are required.

Answer

Use BufferedWriter and call write() then flush() periodically.

Answer

Use PrintWriter with autoFlush enabled.

Answer

Use FileWriter without any buffering.

Question 8

You are responsible for a Java 17 application that processes user uploads. The application uses a custom AutoCloseable resource, UploadSession, which must always be closed after use to free server resources. A junior developer wrote the following code:

```
UploadSession session = new UploadSession();
try {
    session.upload(data);
    // more processing
} catch (UploadException e) {
    log.error("Upload failed", e);
} finally {
    session.close();
}
```

During a code review, you notice that the close() method of UploadSession throws a checked CloseException. The current code does not handle this exception. Which course of action should you recommend to ensure the application is robust and follows best practices?

Accepted Answer

Rewrite the code to use try-with-resources: try (UploadSession session = new UploadSession()) { ... } catch (UploadException e) { ... }. Try-with-resources automatically calls the close() method on the UploadSession resource when the try block exits, whether normally or abruptly. This eliminates the need for an explicit finally block and ensures that any checked exception thrown by close() is either caught or propagated according to the developer's declared exception handling, making the code both robust and concise.

Answer

Add a try-catch block inside the finally block to handle CloseException from session.close().

Answer

Declare the method with throws CloseException, and remove the finally block.

Answer

Keep the code as-is. The CloseException is not critical; it can be ignored.

Question 9

A company needs to read a large text file (over 2 GB) line by line in a Java application while minimizing memory footprint. Which approach is most efficient?

Accepted Answer

Use Files.lines(path) with try-with-resources. `Files.lines(path)` returns a `Stream<String>` that lazily reads lines from the file, processing them one at a time without loading the entire file into memory. Combined with try-with-resources, the underlying `BufferedReader` is automatically closed, ensuring efficient resource management even for files over 2 GB.

Answer

Use Files.readAllLines(path)

Answer

Use FileOutputStream with read() loop

Answer

Use Scanner with File and loop hasNextLine()

Question 10

What is the output of the following code?

List<Integer> list = List.of(0, 1, 2, 3);
System.out.println(list.indexOf(0) + " " + list.lastIndexOf(3));

Accepted Answer

0 3. The list is [0, 1, 2, 3]. The indexOf(0) returns 0 because 0 is at index 0. The lastIndexOf(3) returns 3 because 3 is at index 3. The output is "0 3".

Answer

0 2

Answer

1 2

Answer

1 3

Question 11

A class `Transaction` is declared as `sealed`. Which statement correctly implements a permitted subclass?

Accepted Answer

`public non-sealed class Refund extends Transaction`. A sealed class requires its permitted subclasses to be explicitly declared with `sealed`, `non-sealed`, or `final`. The `non-sealed` modifier allows the subclass to be extended further, which is valid for a permitted subclass of a sealed class.

Answer

`public sealed class Refund extends Transaction permits CashRefund`

Answer

`public final class Refund extends Transaction`

Answer

`public class Refund extends Transaction`

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

Refer to the exhibit. What is the most likely cause of this exception?

Accepted Answer

The class definition has changed and the serialVersionUID is not explicitly defined.. When a class definition changes (e.g., adding/removing fields) and the class does not explicitly declare a `serialVersionUID`, the JVM computes one automatically based on the class structure. After deserialization, if the computed UID differs from the UID stored in the serialized stream, an `InvalidClassException` is thrown. This is the most common cause of deserialization failures in practice.

Answer

The serialized object is corrupted.

Answer

The JVM versions are incompatible.

Answer

The file contains data that is not a serialized object.

Question 14

Given: for(int i=0; i<3; i++) { for(int j=0; j<3; j++) { if(i==1 && j==1) break; } } What is the value of i after the outer loop completes?

Accepted Answer

3. The outer loop variable `i` increments from 0 to 2. When `i` is 1 and `j` is 1, the `break` statement exits only the inner `for` loop, not the outer loop. The outer loop continues to its next iteration, incrementing `i` to 2, then to 3. When `i` becomes 3, the outer loop condition `i < 3` fails, so the loop terminates. Thus, after the outer loop completes, `i` is 3.

Answer

1

Answer

2

Answer

4

Question 15

A developer writes: list.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting())); What is the result type and content?

Accepted Answer

Both B and C.. Option A, 'Both B and C,' is the correct answer because both statements accurately describe the result. Collectors.groupingBy with Function.identity() and Collectors.counting() produces a Map (where T is the element type) containing the frequency of each element, which can also be described as a Map with occurrence counts. Options B and C individually are true but incomplete; the question expects selection of the combination. Option D is incorrect because groupingBy without a map supplier returns a HashMap, not a ConcurrentMap.

Answer

Map<T, Long> where T is element type.

Answer

Map<Object, Long> with number of occurrences of each element.

Answer

A ConcurrentMap.