1Z0-829 Practice Test 6 — 10 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>