1Z0-829 Practice Test 30 — 15 Questions

Question 1

A financial services company runs a Java 17 Spring Boot application that processes real-time stock trades. The application uses a class `TradeProcessor` containing a method `void process(Trade trade)`. This method is invoked by multiple threads concurrently. The `Trade` class is immutable and has fields like `String symbol`, `int quantity`, `double price`. The `TradeProcessor` method updates a shared `HashMap<String, Double>` that tracks the average price per symbol. The update logic is: retrieve the current average for the symbol, compute a new average, and put it back. During high-load testing, the average prices are occasionally incorrect. The development team suspects a race condition. Which course of action should be taken to fix the issue with minimal performance impact?

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

Accepted Answer

Replace `HashMap` with `ConcurrentHashMap` and use the `compute` method to atomically update the average.. `ConcurrentHashMap` provides thread-safe atomic operations like `compute`, which allows you to atomically update the average price per symbol without external synchronization. This avoids the race condition where two threads read the same old average, compute a new one, and overwrite each other's result. Using `compute` ensures the read-modify-write sequence is performed atomically, with minimal performance overhead compared to synchronizing the entire method.

Answer

Use an `AtomicReference` to wrap the `HashMap`.

Answer

Synchronize the entire `process` method.

Answer

Change the `HashMap` to `Hashtable`.

Question 2

A developer writes the following code to print a list of strings in order: list.stream().map(s -> s.toUpperCase()).forEach(System.out::print). They want to parallelize the processing but must preserve the output order. Which change is correct and most appropriate?

Accepted Answer

list.parallelStream().map(s -> s.toUpperCase()).forEachOrdered(System.out::print);. `forEachOrdered` guarantees that elements are processed in encounter order even when the stream is parallelized. The `map` operation is stateless and can run in parallel, but the terminal operation must preserve order, which `forEachOrdered` does by enforcing sequential output in the stream's encounter order.

Answer

list.parallelStream().map(s -> s.toUpperCase()).forEach(System.out::print);

Answer

list.stream().parallel().map(s -> { synchronized(System.out) { return s.toUpperCase(); } }).forEach(System.out::print);

Answer

list.stream().parallel().map(s -> s.toUpperCase()).sequential().forEach(System.out::print);

Question 3

A developer is processing a stream of strings and needs to create a map where the key is the string length and the value is a list of strings of that length. They write the following code: Map> map = strings.stream() .collect(Collectors.groupingBy(String::length)); The code works correctly in a sequential stream, but when they switch to parallelStream, they notice that sometimes the map contains fewer keys than expected. They suspect that the issue is related to the default map implementation used by groupingBy. What is the most likely cause and the correct fix?

Accepted Answer

Replace groupingBy with groupingByConcurrent.. `Collectors.groupingByConcurrent` is designed for concurrent reduction and produces a `ConcurrentMap`, which safely handles parallel stream processing without losing keys. The default `groupingBy` uses a non-concurrent `HashMap` that can lose entries due to race conditions when multiple threads merge partial results.

Answer

Provide a custom thread-safe map factory to groupingBy, e.g., ConcurrentHashMap::new.

Answer

Remove parallelStream() and use stream() to avoid concurrency issues.

Answer

The classifier function (String::length) is not threadsafe.

Question 4

What is the output of the following code?
```java
System.out.println(Stream.of(1, 2).map(i -> i * 2.0).count());
```

Accepted Answer

2. The code is:
```java
System.out.println(Stream.of(1, 2).map(i -> i * 2.0).count());
```
This creates a stream of integers 1 and 2, maps each to a Double (2.0 and 4.0), and then calls count() which returns the number of elements in the stream, which is 2. count() returns a long, but when printed, it outputs 2 (not 2.0). Option C is correct because the stream has two elements.

Answer

2.0

Answer

1

Answer

Compilation error

Question 5

Given: List words = Arrays.asList("apple", "banana", "cherry"); Map> map = words.stream().collect(Collectors.groupingBy(String::length)); System.out.println(map); What is the output?

Accepted Answer

{5=[apple], 6=[banana, cherry]}. The `groupingBy` collector groups stream elements by a classifier function, here `String::length`. Each distinct length becomes a key in the map, and the values are lists of strings with that length. "apple" (length 5) maps to key 5, "banana" and "cherry" (both length 6) map to key 6, producing `{5=[apple], 6=[banana, cherry]}`.

Answer

[apple, banana, cherry]

Answer

{5=[5], 6=[6, 6]}

Answer

{apple=[5], banana=[6], cherry=[6]}

Question 6

Given the exhibit, what is the output? (Assume America/New_York observes daylight saving time, with spring forward on March 12, 2023 at 2:00 AM to 3:00 AM.)

Accepted Answer

A DateTimeException is thrown.. Attempting to create a ZonedDateTime for 2023-03-12 at 02:30 in the America/New_York timezone results in a DateTimeException. This is due to the daylight saving time 'spring forward' transition at 2:00 AM, when clocks jump directly to 3:00 AM, making the time 02:30 non-existent in that timezone. The java.time API strictly validates local date-time values against the timezone's offset transitions and throws an exception for invalid local times.

Answer

null is printed.

Answer

2023-03-12T03:30:00-04:00[America/New_York]

Answer

2023-03-12T02:30:00-05:00[America/New_York]

Question 7

Which THREE are valid ways to iterate over a Map<String, Integer>?

Accepted Answer

for (String key : map.keySet()) { }. `Map.keySet()` returns a `Set` containing all keys, which can be iterated using an enhanced for-each loop. This is a standard way to access keys in a `Map`.

Answer

for (Map.Entry<String, Integer> entry : map) { }

Answer

for (Integer value : map.values()) { }

Question 8

Which loop construct guarantees that the body executes at least once?

Accepted Answer

do-while loop. The do-while loop is the only loop construct in Java that guarantees the body executes at least once because the condition is evaluated after the loop body. This post-test loop design ensures that regardless of the initial condition value, the body runs before any check occurs.

Answer

for loop

Answer

enhanced for loop

Answer

while loop

Question 9

Which design pattern is best suited for creating a family of related objects without specifying their concrete classes?

Accepted Answer

Abstract Factory. The Abstract Factory pattern is designed to create families of related or dependent objects without specifying their concrete classes. It provides an interface for creating families of products, ensuring that the products from one family are used together, which is a core requirement of the question.

Answer

Builder

Answer

Singleton

Answer

Factory Method

Question 10

A financial application processes a daily batch of 10 million transactions. Each transaction is an object with fields: id, amount, and status (an enum: PENDING, APPROVED, REJECTED). The requirement is to find the first APPROVED transaction with amount greater than 1000. The current implementation uses a while loop with a nested if-else structure that checks each transaction sequentially. The loop also logs each transaction status, which involves a moderately expensive file write operation. Performance analysis shows the method is a bottleneck, often taking over 12 seconds. The development team is considering refactoring. Which course of action will most effectively reduce execution time while maintaining the requirement?

Accepted Answer

Replace the while loop with a traditional for loop that uses a break when the first match is found, and defer the logging to a separate batch process after the loop.. It removes the expensive file write operation from the loop, which is the primary cause of the bottleneck. By deferring logging to a separate batch process, the loop can iterate quickly and break immediately upon finding the first APPROVED transaction with amount > 1000, drastically reducing execution time while still meeting the requirement.

Answer

Refactor the while loop into a recursive method that processes one transaction per call and stops when the condition is met.

Answer

Replace the while loop with a parallel stream and use findFirst() to get the first matching transaction.

Answer

Replace the while loop with a for-each loop that breaks when the condition is met, but keep the logging inside the loop.

Question 11

Match each I/O stream class to its description.

Accepted Answer

FileInputStream: Reads bytes from a file. The correct matches are based on the direction (read vs write) and type (byte vs character) of the stream. FileInputStream reads bytes; FileOutputStream writes bytes. BufferedReader reads characters with buffering; BufferedWriter writes characters with buffering.

Answer

FileInputStream: Writes bytes to a file

Answer

BufferedReader: Writes text to a character-output stream

Question 12

A developer needs to iterate over an ArrayList of integers and remove all elements that are less than 10. Which approach is best to avoid ConcurrentModificationException?

Accepted Answer

Use list.removeIf() with a lambda expression.. `list.removeIf()` is a built-in method introduced in Java 8 that safely removes elements from a collection based on a predicate, handling all iteration and modification internally without throwing ConcurrentModificationException. It uses an internal iterator that properly coordinates structural modifications, making it the most concise and reliable approach for this task.

Answer

Use a for loop with index and list.remove(index) decrementing index.

Answer

Use an Iterator with iterator.remove().

Answer

Use a for-each loop with list.remove().

Question 13

Which are valid method references in Java 17?

Accepted Answer

String::new. A is a constructor reference, a valid type of method reference. B is a reference to an instance method of an arbitrary object of type String. D is a reference to a static method. E is a reference to an instance method of the current object, valid in an instance context. C is invalid because null cannot be a qualifier.

Answer

null::equals

Question 14

A developer needs to ensure that a class `Shape` cannot be instantiated but can be extended. Which modifier should be used?

Accepted Answer

abstract. The `abstract` modifier is correct because an abstract class cannot be instantiated directly, but it can be extended by subclasses. This enforces the design intent that `Shape` serves as a base class for specific shapes like `Circle` or `Rectangle`, while preventing the creation of a generic `Shape` object.

Answer

private

Answer

final

Answer

sealed

Question 15

A web application allows users to upload profile pictures. The application saves the files to a directory using the original filename provided by the user. After a security review, the team discovered a critical path traversal vulnerability. Which remediation is most effective in preventing exploitation while maintaining usability?

Accepted Answer

Generate a random UUID as the filename and store the original filename in a database.. Generating a random UUID as the filename eliminates the user's control over the file path, making path traversal attacks impossible. The original filename can be stored in a database for display purposes, preserving usability while ensuring the file is saved with a safe, unpredictable name.

Answer

Store the files in a database BLOB instead of the filesystem.

Answer

Sanitize the filename by removing all occurrences of "../" and "/".

Answer

Check that the file extension is allowed (e.g., .jpg, .png) and no special characters.