1Z0-829 Practice Test 5 — 10 Questions

Question 1

A developer is implementing a batch processing application that reads records from a list and processes them. The method uses a for loop with an index variable. Inside the loop, if a record is null, the developer wants to skip that iteration and continue with the next index. The developer writes: for (int i = 0; i < records.size(); i++) { if (records.get(i) == null) continue; process(records.get(i)); updateCounter(); } However, the counter is not updated correctly. The developer expects the counter to reflect the number of processed (non-null) records. What is the problem?

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

Accepted Answer

The continue statement skips the rest of the loop body, including the counter update.. The `continue` statement immediately jumps to the next iteration of the loop, skipping any remaining code in the current iteration. In this case, `updateCounter()` is placed after the `continue` in the loop body, so when a null record is encountered, the counter update is never executed, causing the counter to not reflect the number of processed (non-null) records.

Answer

The continue statement is only valid inside a while loop.

Answer

The continue statement should be replaced with a break.

Answer

The counter variable should be declared as volatile.

Question 2

An application uses `--add-opens java.base/java.lang=ALL-UNNAMED` to allow reflective access to `java.lang` internals from the classpath. After migrating to a module, the flag is changed to `--add-opens java.base/java.lang=com.example.app`. Yet reflective access still fails with `InaccessibleObjectException`. What is the most likely reason?

Accepted Answer

The reflective call is made from a different module than com.example.app.. `--add-opens` specifies which module's package is opened to which target module. When the flag is changed from `ALL-UNNAMED` to `com.example.app`, only code in the `com.example.app` module is granted reflective access. If the reflective call originates from a different module (e.g., a third-party library or another application module), the `InaccessibleObjectException` will still be thrown because that module is not listed as the target.

Answer

The class performing reflection is in an unnamed module.

Answer

The module does not read the module java.base.

Answer

The module name in --add-opens is misspelled.

Question 3

Which of the following creates an immutable map with two entries?

Accepted Answer

Map.of("a",1,"b",2). `Map.of()` returns an immutable map containing exactly the key-value pairs provided as arguments. This factory method was introduced in Java 9 and creates a fixed-size, unmodifiable map with the two entries "a"→1 and "b"→2.

Answer

new HashMap<>(Map.of("a",1,"b",2))

Answer

Collections.emptyMap()

Answer

None of the above

Answer

new HashMap<>()

Question 4

A developer is designing a method that processes a stream of Employee objects. The method needs to group employees by department and then, within each department, sort by salary in descending order, and collect the top 3 highest-paid employees per department into a list. Which approach correctly accomplishes this using streams?

Accepted Answer

stream.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.collectingAndThen(Collectors.toList(), list -> list.stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).limit(3).collect(Collectors.toList())))). It uses `Collectors.groupingBy` to partition employees by department, then applies `Collectors.collectingAndThen` to post-process each department's list. Inside, it sorts the list by salary in descending order, limits to the top 3, and collects them into a new list. This ensures each department's result is independently sorted and truncated.

Answer

stream.collect(Collectors.toMap(Employee::getDepartment, e -> { List l = new ArrayList<>(); l.add(e); return l; }, (l1, l2) -> { l1.addAll(l2); l1.sort(Comparator.comparing(Employee::getSalary).reversed()); return l1.subList(0, Math.min(3, l1.size())); }))

Answer

stream.sorted(Comparator.comparing(Employee::getSalary).reversed()).collect(Collectors.groupingBy(Employee::getDepartment, Collectors.toList())).values().stream().map(l -> l.subList(0, Math.min(3, l.size()))).collect(Collectors.toList())

Answer

stream.collect(Collectors.groupingBy(Employee::getDepartment, Collectors.toList())).entrySet().stream().flatMap(e -> e.getValue().stream().sorted(Comparator.comparing(Employee::getSalary).reversed()).limit(3)).collect(Collectors.toList())

Question 5

A developer is working on a high-performance trading application that processes market data. The system needs to maintain a sorted list of order IDs (Long values) that are frequently inserted and removed. The current implementation uses a TreeSet<Long> to store the order IDs. The application is experiencing performance degradation under high load, and profiling shows that the TreeSet operations are the bottleneck. The developer considers replacing the TreeSet with a data structure that offers O(log n) insertion and removal but also supports O(log n) indexed access (e.g., get by index) for batch processing. Which of the following should the developer choose to improve performance while maintaining the sorted order and adding indexed access?

Accepted Answer

No standard Java Collections class fulfills all requirements; consider a custom implementation.. No standard Java Collections class provides O(log n) insertion, removal, and O(log n) indexed access while maintaining sorted order. TreeSet offers O(log n) insertion/removal but lacks indexed access; ArrayList provides O(1) indexed access but requires O(n log n) sorting after each insertion; PriorityQueue offers O(log n) insertion/removal but only O(1) peek access, not indexed access. A custom data structure like an order statistic tree (e.g., a balanced binary search tree with subtree sizes) is needed to meet all requirements.

Answer

Replace with TreeMap<Long, Boolean> and use the key set for iteration and indexed access via keySet().toArray().

Answer

Replace with PriorityQueue<Long> and use poll() for removal and toArray() for indexed access.

Answer

Replace with ArrayList<Long> and use Collections.sort() after each insertion.

Question 6

Consider try-with-resources where resource1 is opened first, then resource2. During closing, both throw exceptions. Which exception is propagated to the caller?

Accepted Answer

The exception from resource2 (closed first) with resource1's exception as suppressed.. In try-with-resources, resources are closed in the reverse order of their declaration. Resource2 (declared second) is closed first, and resource1 (declared first) is closed last. If both throw exceptions during closing, the exception from the first resource closed (resource2) is propagated to the caller, and the exception from the second resource closed (resource1) is added as a suppressed exception. This matches option B.

Answer

The exception from resource1 (closed last) with resource2's exception as suppressed.

Answer

Only the exception from the resource declared first is propagated.

Answer

Both exceptions are wrapped in a new exception.

Question 7

What is the result of executing the following code snippet?

BigDecimal d1 = new BigDecimal("1.00");
BigDecimal d2 = new BigDecimal("1.0");
System.out.println(d1.equals(d2));

Accepted Answer

false. The `equals` method of `BigDecimal` compares both the numeric value and the scale (number of digits after the decimal point). Since `new BigDecimal("1.00")` has a scale of 2 and `new BigDecimal("1.0")` has a scale of 1, they are not considered equal by `equals`, even though they represent the same mathematical value. Therefore, the output is `false`.

Answer

compile error

Answer

true

Answer

1

Question 8

Which TWO are correct about parallel streams in Java? (Choose TWO.)

Accepted Answer

Parallel streams use the common ForkJoinPool by default.. Option D is correct because parallel streams in Java execute their tasks on the common ForkJoinPool by default, which is obtained via ForkJoinPool.commonPool() and sized to Runtime.getRuntime().availableProcessors() - 1. Option E is correct because parallel stream pipelines require stateless, non-interfering, and side-effect-free lambda functions; shared mutable state or interference between operations can produce nondeterministic or incorrect results due to concurrent execution across threads. Option A is wrong because parallelism adds overhead (splitting, task scheduling, merging) and can be slower than sequential streams for small data sets or cheap operations. Option B is wrong because lambdas that mutate shared state, rely on encounter order, or are not thread-safe can break under parallel execution. Option C is wrong because parallel streams do not guarantee encounter order unless the terminal operation and stream source explicitly preserve it (e.g., using forEachOrdered), and unordered sources or operations may yield results in any order.

Answer

Parallel streams always improve performance over sequential streams.

Answer

Any lambda expression is safe to use in a parallel stream.

Answer

Using parallel streams guarantees the order of elements in the result.

Question 9

Which TWO practices improve the security of Java serialization?

Accepted Answer

Mark sensitive fields as transient to exclude them from serialization.. Option B is correct because marking sensitive fields (e.g., passwords, keys) as transient excludes them from the default serialization process, so their values are never written to the byte stream and cannot be recovered by an attacker deserializing the object. Option D is correct because overriding readObject() lets you validate and sanitize field values after deserialization, rejecting malformed or malicious state before it is used, which mitigates gadget-chain and tampering attacks. Option A is not a security practice: throwing NotSerializableException from writeObject() merely prevents serialization of that class and does not protect against deserialization of crafted streams. Option C is wrong because serialVersionUID is only a version-compatibility identifier; a random value does not prevent malicious serialization and can actually break legitimate deserialization. Option E is not inherently secure: Externalizable gives full control over the wire format but shifts the burden of validation to the developer and, without explicit checks in readExternal(), can be just as vulnerable as default serialization.

Answer

Disable serialization by throwing NotSerializableException from writeObject().

Answer

Set a random serialVersionUID to prevent malicious serialization.

Answer

Use Externalizable for full control over serialization format.

Question 10

Which THREE conditions must be true for a method to override another method in a subclass? (Choose three.)

Accepted Answer

The method name must be the same.. Option C is correct because an overriding method must have exactly the same name as the method it overrides in the superclass, which is the fundamental basis for the override relationship. Option D is correct because the parameter list (number, types, and order of parameters) must match exactly; otherwise the method would be an overload, not an override. Option E is correct because Java permits covariant return types, meaning the overriding method's return type may be the same as, or a subtype of, the overridden method's return type. Option A is incorrect because static methods are hidden rather than overridden, and an instance method cannot override a static method. Option B is incorrect because the access modifier must be the same or less restrictive (wider), not more restrictive; a more restrictive modifier would cause a compile-time error.

Answer

The method must be static in the superclass.

Answer

The access modifier must be the same or more restrictive.