1Z0-829 Practice Exam 4 — 20 Questions

Question 1

What is the output of the following code? int i=5; do { System.out.print(i); i--; } while(i>0);

Accepted Answer

54321. The do-while loop executes the body first, printing the current value of i (5), then decrements i to 4. The loop continues while i > 0, so it prints 5, 4, 3, 2, 1, and stops when i becomes 0, as the condition i > 0 is false. This results in the output "54321".

Answer

Compilation error

Answer

543210

Answer

5432

Question 2

A Java application uses FileChannel to copy a file to a remote network drive. The developer wants to ensure atomic file replacement on the destination. Which approach is correct?

Accepted Answer

Use Files.move() with StandardCopyOption.ATOMIC_MOVE.. `Files.move()` with `StandardCopyOption.ATOMIC_MOVE` guarantees that the file replacement on the destination file system is atomic — either the entire move succeeds or the original state remains intact. This is essential for remote network drives where partial writes or concurrent access could leave the destination in an inconsistent state. The `ATOMIC_MOVE` option leverages file system–level atomic rename operations (e.g., NFS or SMB support) to ensure no intermediate state is visible.

Answer

Delete the destination file, then rename the temporary file.

Answer

Use FileChannel.transferTo() to write directly.

Answer

Use Files.copy() with REPLACE_EXISTING option.

Question 3

A developer creates a Java application that uses the new 'jpackage' tool to create an installer for Windows. The application is modular and has a main class declared in module-info. Which option is required to specify the main class when using jpackage?

Accepted Answer

--module. For a modular application with a main class declared in module-info, jpackage requires the `--module` option to specify the module name and, optionally, the main class (e.g., `--module com.example/com.example.Main`). This is because jpackage uses the module system to resolve the entry point, not a classpath or JAR-based approach.

Answer

-classpath

Answer

--module-path

Answer

--main-jar

Question 4

Which of the following correctly sorts an array of integers (int[] arr) in descending order?

Accepted Answer

Integer[] boxed = Arrays.stream(arr).boxed().toArray(Integer[]::new); Arrays.sort(boxed, Collections.reverseOrder()); arr = Arrays.stream(boxed).mapToInt(i->i).toArray();. It demonstrates the proper technique for sorting a primitive int array in descending order. The `Arrays.sort()` method does not accept a `Comparator` for primitive arrays, so the array must first be boxed into an `Integer[]` using `Arrays.stream(arr).boxed().toArray(Integer[]::new)`. After sorting with `Collections.reverseOrder()`, the result is unboxed back to `int[]` via `mapToInt(i->i).toArray()`. This approach correctly leverages the `Comparator` interface, which only works with object types.

Answer

Arrays.sort(arr, Collections.reverseOrder());

Answer

None of the above, because primitive arrays cannot be sorted in descending order.

Answer

Arrays.sort(arr, (a,b) -> b - a);

Answer

Arrays.parallelSort(arr, (a,b) -> b - a);

Question 5

Which of the following correctly describes the behavior of the following code? List list = new ArrayList<>(); list.add("A"); list.add("B"); for (String s : list) { if (s.equals("A")) { list.remove(s); } } System.out.println(list);

Accepted Answer

ConcurrentModificationException is thrown. The code uses an enhanced for-each loop to iterate over an ArrayList while calling `list.remove(s)` when the element equals "A". This modifies the list structurally during iteration, which causes the iterator (used internally by the for-each loop) to detect the concurrent modification and throw a `ConcurrentModificationException` at runtime. The exception is thrown because the iterator's `modCount` check fails when the list is modified outside of the iterator's own `remove` method.

Answer

Compilation error

Answer

[B]

Answer

[A, B] unchanged

Question 6

Which is true about CopyOnWriteArrayList?

Accepted Answer

Modifications are expensive as they create a new array.. CopyOnWriteArrayList is a thread-safe variant of ArrayList where all mutative operations (add, set, remove, etc.) are implemented by making a fresh copy of the underlying array. This design makes modifications expensive because each modification requires copying the entire array, but it provides safe iteration without locking. Option C correctly identifies that modifications are expensive due to the array copy.

Answer

It is not thread-safe.

Answer

Iterators reflect concurrent modifications.

Answer

It is optimized for frequent modifications.

Question 7

Given an enum Direction { NORTH, SOUTH, EAST, WEST } and a variable d of type Direction, which code snippet correctly uses a switch expression to map each direction to an abbreviation (N, S, E, W) without using a default branch?

Accepted Answer

switch (d) { case NORTH -> "N"; case SOUTH -> "S"; case EAST -> "E"; case WEST -> "W"; }. It uses the arrow syntax in a switch expression, which requires that all possible enum values are covered without a default branch. Since Direction has exactly four constants and each is mapped to a yield value via the arrow, the switch is exhaustive and compiles successfully.

Answer

switch (d) { case NORTH: yield "N"; case SOUTH: yield "S"; case EAST: yield "E"; case WEST: yield "W"; }

Answer

switch (d) { case NORTH -> "N"; case SOUTH -> "S"; case EAST -> "E"; }

Answer

switch (d) { case NORTH: yield "N"; case SOUTH: yield "S"; case EAST: yield "E"; default: yield "W"; }

Question 8

Which three of the following are valid methods in the String class in Java 17? (Choose three.)

Accepted Answer

translateEscapes(). `translateEscapes()` is a valid instance method introduced in Java 14 (and present in Java 17) that translates escape sequences (e.g., `
` to newline) in a string. Option C is correct because `toLowerCase(Locale)` is a standard overloaded method in the String class that converts all characters to lowercase using the specified locale. Option D is correct because `transform(Function<String, String>)` is a valid method added in Java 12 that applies the given function to the string and returns the result.

Answer

substring(int, int, Locale)

Answer

indent(String)

Question 9

Which THREE of the following are valid ways to create a new ArrayList<Integer>? (Select three.)

Accepted Answer

new ArrayList<>(Arrays.asList(1,2,3)). `Arrays.asList(1,2,3)` returns a fixed-size `List`, and passing it to the `ArrayList` constructor creates a new, mutable `ArrayList` containing the same elements. This is a standard way to initialize an `ArrayList` with known values.

Answer

new ArrayList<>(10, 20, 30)

Answer

(ArrayList<Integer>) Arrays.asList(1,2,3)

Question 10

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

Accepted Answer

Duration can be negative.. The java.time.Duration class can represent negative durations, such as when the end instant is before the start instant in a Duration.between() call. Option C is correct because all classes in the java.time package, including Duration, are immutable and thread-safe by design, ensuring safe concurrent access without synchronization.

Answer

Duration supports units like months and years.

Answer

Duration.between(LocalDate.now(), LocalDate.now()) returns a Duration.

Answer

Duration uses a days-based representation.

Question 11

Which statement about Collection interface remove methods is correct?

Accepted Answer

Collection.remove(Object) removes the first occurrence and returns boolean.. The Collection interface's remove(Object) method removes the first occurrence of the specified element from the collection, if present, and returns true if the collection was modified (i.e., the element was found and removed). This behavior is defined in the Java Collections Framework and applies to all implementations of Collection, such as ArrayList and HashSet.

Answer

List.remove(int) removes element at index and returns the removed element.

Answer

Collection.remove(Object) removes all occurrences of the element.

Answer

Both B and C

Question 12

Which TWO statements about Arrays.asList() are true? (Select two.)

Accepted Answer

It returns a fixed-size list backed by the original array.. `Arrays.asList()` returns a fixed-size list backed by the original array, meaning the list's size cannot be changed (no add or remove operations allowed). Option E is correct because any modification to the returned list (e.g., setting an element) directly modifies the underlying array, and vice versa, as the list is a view of the array.

Answer

It supports adding and removing elements.

Answer

It returns a new ArrayList with a copy of the elements.

Answer

It can be used to convert an array to a mutable list if wrapped with new ArrayList<>().

Question 13

Which TWO are valid ways to create an immutable list in Java 17? (Choose two.)

Accepted Answer

Collections.unmodifiableList(new ArrayList<>(List.of("a", "b"))). `Collections.unmodifiableList()` wraps a mutable list in an unmodifiable view, preventing any structural modifications. Option D is correct because `List.copyOf()` creates an immutable list from an existing collection, throwing `NullPointerException` if any element is null. Both produce lists that cannot be modified after creation.

Answer

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

Answer

List.of(List.of("a", "b"))

Answer

new ArrayList<>(List.of("a", "b"))

Question 14

A developer creates a module `com.example.app` that requires `java.sql` and `com.example.util`. The module is compiled and packaged into a JAR. When launching the application with `java --module-path app.jar:lib --module com.example.app`, it fails with `java.lang.module.ResolutionException: Module com.example.util not found`. What is the most likely cause?

Accepted Answer

The module `com.example.util` is not in the module path.. The error `Module com.example.util not found` indicates that the module system cannot locate `com.example.util` on the module path. Since the command specifies `--module-path app.jar:lib`, the JAR for `com.example.util` must be present in the `lib` directory (or another directory on that path). If it is missing or not in the correct location, the module resolution fails. Option B correctly identifies that the module is simply not on the module path.

Answer

The module `com.example.util` is an automatic module and requires specific flags.

Answer

The module `com.example.util` is a named module but not exported.

Answer

The module `com.example.util` is on the classpath and not visible to module system.

Question 15

Consider: List list = new LinkedList<>(); list.add(10); list.add(20); list.add(0,5); System.out.println(list); What is the output?

Accepted Answer

[5,10,20]. The code creates a LinkedList and adds 10, then 20. The third call `list.add(0,5)` inserts 5 at index 0, shifting existing elements to the right. The resulting list is [5,10,20], so option B is correct.

Answer

[10,5,20]

Answer

[10,20,5]

Answer

[5,10,20] but with type warning

Question 16

Given: TreeSet set = new TreeSet<>(List.of(3,1,2)); set.add(2); System.out.println(set); What is the output?

Accepted Answer

[1,2,3]. E is correct because TreeSet maintains elements in their natural sorted order (ascending for integers). The list [3,1,2] is sorted to [1,2,3], and adding 2 again has no effect since TreeSet does not allow duplicates. The output is [1,2,3].

Answer

[1,2]

Answer

[1,3,2]

Answer

[3,1,2]

Answer

UnsupportedOperationException

Question 17

Which of the following is a checked exception in Java?

Accepted Answer

SQLException. SQLException is a checked exception because it extends Exception directly (not RuntimeException). Checked exceptions must be either caught with a try-catch block or declared in the method signature using 'throws'. SQLException is thrown by JDBC API methods when database access errors occur, forcing the developer to handle potential SQL failures at compile time.

Answer

NullPointerException

Answer

ArrayIndexOutOfBoundsException

Answer

IllegalArgumentException

Question 18

What happens when a finally block throws an exception?

Accepted Answer

The exception from the try block is suppressed and the finally exception is reported.. When a finally block throws an exception, the JVM suppresses the exception that was thrown from the try block (if any) and propagates the exception thrown from the finally block. This behavior is defined in the Java Language Specification (JLS §14.20.2) and ensures that the finally block's exception takes precedence, as the finally block is executed after the try block completes abruptly.

Answer

The JVM logs both exceptions and then terminates the thread.

Answer

The exception from the try block is propagated and the finally exception is ignored.

Answer

Both exceptions are reported as suppressed exceptions of a new exception.

Question 19

A developer wants to ensure that a block of code always executes regardless of whether an exception occurs or not, and that any exception thrown in the block is not swallowed. Which construct should be used?

Accepted Answer

try-finally. The try-finally construct ensures that the finally block always executes after the try block, regardless of whether an exception occurs, and it does not catch or swallow any exception. This meets the requirement of guaranteed execution without suppressing the exception, as the exception propagates up the call stack.

Answer

try-catch with empty catch block

Answer

try-catch-finally with catch that rethrows the exception

Answer

try-with-resources without catch