1Z0-829 Practice Questions 2 — 50 Questions

Question 1

A developer runs `java --list-modules` and sees the above output on a standard JDK installation. What does this output represent?

Accepted Answer

The set of modules available in the current JDK.. The `java --list-modules` command outputs the names of all observable modules that are part of the current JDK installation. This includes all platform modules (e.g., `java.base`, `java.sql`, `jdk.compiler`) that are available for use, regardless of whether they are currently required or loaded by an application. Option C correctly identifies this as the set of modules available in the current JDK.

Answer

The modules that are part of the java.base module.

Answer

The modules that are required by the current application.

Answer

The modules that are currently loaded by the JVM.

Question 2

Given: Object obj = null; String s = switch(obj) { case null -> "null"; case String str -> str; default -> "other"; }; What is the result?

Accepted Answer

"null". In Java 14+, switch expressions can handle null values directly using a 'case null' label. Since obj is null, the switch matches the 'case null' branch and returns the string "null". Option D is correct because the code compiles and executes without error, producing "null".

Answer

Compilation error

Answer

NullPointerException

Answer

"other"

Question 3

What is the result of executing the code in the exhibit?

Accepted Answer

The code does not compile because methodA does not declare that it throws Exception.. The code does not compile because methodA explicitly throws an IOException, but the catch block in main catches Exception (a broader type). However, the compiler performs improved rethrow analysis only when the exception parameter is effectively final and the catch block is multi-catch or rethrows a checked exception that is declared in the method signature. Here, methodA does not declare that it throws Exception, and the catch block catches Exception, which is not a declared exception in methodA's throws clause, causing a compilation error.

Answer

The code compiles and prints 'Caught in main: IOException' because the compiler uses improved rethrow analysis.

Answer

Prints: Caught in main: Exception

Answer

Prints: Caught in main: IOException

Question 4

Which two statements are true about the java.util.Comparator and java.lang.Comparable interfaces? (Choose two.)

Accepted Answer

Comparator can be used to sort a list in multiple ways.. The Comparator interface allows you to define multiple different comparison strategies (e.g., by name, by age, by salary) for the same class, enabling sorting of a list in multiple ways. Option D is correct because the Comparable interface is used to define a natural ordering of objects (e.g., String's lexicographic order, Integer's numeric order) by implementing the compareTo method.

Answer

Comparator's compare method returns a boolean.

Answer

A class implementing Comparable must override equals().

Answer

Comparator is in java.lang package.

Question 5

A company runs a Java 17 microservice that processes real-time financial transactions. The application receives a large number of transactions per second, each with a timestamp, amount, and type. The current implementation uses a sequential stream to filter and aggregate transactions into a Map. The team observes high latency and CPU spikes during peak loads. They suspect the stream pipeline is inefficient. The pipeline code is: Map stats = transactions.stream() .filter(t -> t.getTimestamp().isAfter(Instant.now().minusSeconds(60))) .collect(Collectors.groupingBy(Transaction::getType, Collectors.summarizingDouble(Transaction::getAmount))); The transactions list is an ArrayList that is frequently modified by other threads (adding new transactions). The system has multiple CPU cores available. Which of the following changes is the MOST effective way to improve performance while maintaining correctness?

Accepted Answer

Use .parallelStream() on a snapshot (new ArrayList<>(transactions)) and keep the same collector.. Taking a snapshot via new ArrayList<>(transactions) provides a consistent, immutable view for the stream, reducing contention and allowing parallelStream to leverage multiple cores. However, the copy operation itself is not thread-safe and can throw ConcurrentModificationException if the list is being modified simultaneously. Despite this risk, option B is the most effective among the choices because it attempts to isolate the stream from concurrent modifications and uses a parallel-friendly collector. To guarantee correctness, additional synchronization would be required, but none of the other options offer a better combination of performance and safety.

Answer

Use .stream().parallel() with a custom thread pool and ensure the stream source is not modified during operation.

Answer

Replace ArrayList with CopyOnWriteArrayList and use .parallelStream() with the same collector.

Answer

Replace the collector with Collectors.groupingByConcurrent() and use .parallelStream() directly on the original list.

Question 6

The code fails to compile. What is the reason?

Accepted Answer

The flatMap method requires a function that returns a Stream, but String::chars returns an IntStream.. The `chars()` method on `String` returns an `IntStream`, not a `Stream`. The `flatMap` method on a `Stream` expects a function that returns a `Stream`, but `String::chars` returns an `IntStream`, which is a primitive stream and not a subtype of `Stream`. This type mismatch causes a compilation error.

Answer

The collect method is not applicable for a Stream<Character>.

Answer

The method reference String::chars is not a valid method reference.

Answer

The chars() method returns a Stream, but flatMap requires a function that returns a Stream.

Question 7

A financial application uses Java SE 17 with a custom date format. The requirement is to parse strings like "2023-12-31T23:59:59.999Z" into an Instant. The existing code uses SimpleDateFormat with pattern "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'" and then calls parse(). It works fine in single-threaded testing, but in production under load, intermittent parsing failures occur with DateTimeParseException or wrong values. The application is multi-threaded and reuses the same formatter instance. Which single change should be made to fix the issue while maintaining performance?

Accepted Answer

Replace SimpleDateFormat with DateTimeFormatter.ISO_INSTANT and use Instant.from(). `SimpleDateFormat` is not thread-safe, and reusing a single instance across multiple threads causes race conditions leading to parsing failures. Replacing it with `DateTimeFormatter.ISO_INSTANT` (which is immutable and thread-safe) and using `Instant.from()` directly parses the ISO 8601 string without any synchronization overhead, maintaining performance while fixing the concurrency bug.

Answer

Wrap the parse call in a synchronized block

Answer

Use a ThreadLocal<SimpleDateFormat> to give each thread its own instance

Answer

Create a new SimpleDateFormat instance for each parse call

Question 8

A developer needs to parse the string "2023-12-31T23:59:60Z" (a leap second) into a java.time.Instant. Which statement is true?

Accepted Answer

It returns an Instant representing 2023-12-31T23:59:59Z with an added nanosecond.. Java.time.Instant.parse() handles leap seconds by converting them to the last valid second of the minute (23:59:59) and then adding a nanosecond to account for the extra second. This behavior is specified by the ISO-8601 standard and the Java Time API, which does not support a true 60th second but represents it as an Instant with a fractional second adjustment.

Answer

It returns an Instant representing 2023-12-31T23:59:59Z, ignoring the leap second.

Answer

It throws a DateTimeParseException because 60 seconds is invalid.

Answer

It returns null because the string is invalid.

Question 9

What is the output of the code in the exhibit?

Accepted Answer

1.234,57 €. The code uses `NumberFormat.getCurrencyInstance(Locale.GERMANY)`, which formats currency according to the German locale. In Germany, the currency symbol (€) is placed after the amount, a comma is used as the decimal separator, and a period is used as the thousands separator. Thus, 1234.5678 is rounded to two decimal places using half-even rounding and displayed as '1.234,57 €'.

Answer

1,234.57 €

Answer

€1,234.57

Answer

€ 1.234,57

Question 10

A lambda expression that takes two integers and returns a boolean indicating whether the first is greater than the second is best represented by which functional interface?

Accepted Answer

BiPredicate. BiPredicate is a functional interface that takes two arguments (both Integer) and returns a boolean, which exactly matches the lambda expression's signature (int, int) -> boolean. The lambda can be written as (a, b) -> a > b, and BiPredicate is the standard interface for such two-argument boolean-valued operations.

Answer

BiFunction<Integer, Integer, Boolean>

Answer

Predicate<Integer>

Answer

BinaryOperator<Boolean>

Question 11

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 12

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 13

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 14

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 15

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 16

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 17

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 18

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 19

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 20

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.