1Z0-829 Practice Test 17 — 15 Questions

Question 1

```java
int count = 0;
for (int i = 0; i < 5; ++i) {
    if (i == 3) break;
    count++;
}
System.out.println(count);
```
What is the output?

Accepted Answer

3. The code uses a loop that increments a variable count. It breaks when a certain condition (e.g., when a loop index equals 3) is met, after counting three iterations. Therefore, the output is 3.

Answer

4

Answer

5

Answer

Compilation error

Question 2

Which TWO are valid lambda expressions? (Choose two.)
A. (int a, int b) -> a + b
B. a, b -> a + b
C. (a, b) -> a + b
D. (a, b) -> { a + b; }
E. (int a, b) -> a + b

Accepted Answer

(int a, int b) -> a + b. Options A and C are valid lambda expressions. Option A uses explicit parameter types, which is allowed in lambda expressions. Option C uses inferred types with parentheses, also valid. Option B is invalid because multiple lambda parameters require parentheses. Option D is invalid because the block body does not contain a return statement, and the expression statement a + b; is not a valid return statement. Option E is invalid because it mixes explicit and inferred parameter types; if one parameter has an explicit type, all must have explicit types.

Answer

a, b -> a + b

Answer

(a, b) -> { a + b; }

Answer

(int a, b) -> a + b

Question 3

A developer is refactoring a legacy codebase to use streams. The original code iterates over a list of 'Order' objects, filters orders with status 'PENDING', sorts them by date, and collects the order IDs into a set. Which stream pipeline correctly replaces this logic?

Accepted Answer

orders.stream().filter(o->o.getStatus().equals("PENDING")).sorted(Comparator.comparing(Order::getDate)).map(Order::getId).collect(Collectors.toSet()). It first filters orders with status 'PENDING', then sorts them by date using a Comparator, then maps each Order to its ID, and finally collects the IDs into a Set. This preserves the original logic: filter before sorting (to reduce the number of elements to sort), and map after sorting (since sorting requires Order objects, not IDs). Collecting into a Set automatically deduplicates IDs, matching the original intent.

Answer

orders.stream().filter(o->o.getStatus().equals("PENDING")).sorted(Comparator.comparing(Order::getDate)).collect(Collectors.toSet())

Answer

orders.stream().filter(o->o.getStatus().equals("PENDING")).map(Order::getId).sorted().collect(Collectors.toSet())

Answer

orders.stream().sorted(Comparator.comparing(Order::getDate)).filter(o->o.getStatus().equals("PENDING")).map(Order::getId).collect(Collectors.toSet())

Question 4

Which THREE of the following are valid ways to create an infinite stream? (Choose three.)

Accepted Answer

IntStream.generate(() -> 0). `IntStream.generate(() -> 0)` uses a supplier that always returns 0, producing an infinite stream of zeros. The `generate` method creates an unordered infinite stream by repeatedly invoking the supplier, with no termination condition.

Answer

IntStream.range(0, Integer.MAX_VALUE)

Answer

Stream.of(1,2,3)

Question 5

A developer writes a method that uses a for loop to iterate over a list of strings and remove elements that match a specific pattern using the list's remove(int index) method. The developer uses an index variable that increments normally. However, after running the method, some elements that should have been removed are still present, and some elements are skipped. The list initially contains [A, B, C, D, E] and the developer expects to remove B and D. After the loop, the list is [A, C, E] as expected? Actually, the developer observes that after the loop, the list contains [A, C, D, E] (D was not removed). What is the most likely cause?

Accepted Answer

The for loop uses an index that becomes invalid after removal.. When using a for loop with an index variable that increments normally, removing an element via `remove(int index)` causes all subsequent elements to shift left. This means the loop effectively skips the element that moves into the current index after a removal. In this scenario, after removing B at index 1, element C moves to index 1, but the loop increments i to 2, so C is never checked. Then at i=2, the loop sees D (originally at index 3). If the removal condition for D is checked at this point and matches, D would be removed, yielding [A, C, E]. However, the observed result is [A, C, D, E], indicating D was not removed. This can happen if the loop's condition uses a fixed bound (e.g., original size) causing an `IndexOutOfBoundsException` (not shown) or if the removal pattern is based on original indices that become invalid after the first removal. The most likely cause is that the index variable becomes stale after removal, leading to skipped elements or missed removals.

Answer

The list is unmodifiable, so remove throws UnsupportedOperationException.

Answer

The remove method is called with the wrong index.

Answer

The for loop uses an iterator that throws ConcurrentModificationException.

Question 6

A financial application processes millions of transactions daily. The original code uses a for loop to aggregate transactions into a Map<Long, TransactionSummary> where the key is account ID. To improve performance, a developer refactors it using parallel streams: transactions.parallelStream() .collect(Collectors.toMap( Transaction::getAccountId, Function.identity(), (t1, t2) -> t1.merge(t2), // merging logic HashMap::new )); After deployment, they observe that the resulting map is smaller than expected and some transaction summaries are missing. Profiling shows the merge function is called infrequently, suggesting that the map is losing entries. What is the most likely cause and the correct fix?

Accepted Answer

Replace HashMap::new with ConcurrentHashMap::new in the collector.. The issue is that `HashMap::new` is not thread-safe. When `parallelStream()` splits the stream into multiple threads, each thread creates its own `HashMap` for partial results. These partial maps are then merged using the collector's combiner, but `HashMap` does not guarantee thread safety during concurrent access or merging. Using `ConcurrentHashMap::new` ensures that the map can be safely populated and combined across threads, preventing lost entries. The merge function itself is associative (merging two summaries into one), so the problem is purely the thread-unsafe map supplier.

Answer

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

Answer

The merge function is not associative; change it to use a combiner that is associative.

Answer

Use forEach with a ConcurrentHashMap and putIfAbsent to manually merge.

Question 7

Given nested loops with labels, which statement correctly breaks out of the outer loop?

Accepted Answer

break outer;. The labeled break statement 'break outer;' terminates the outer loop when executed inside the inner loop. In Java, a label (e.g., 'outer:') placed before a loop allows a break or continue to target that specific loop, overriding the default behavior of breaking only the innermost loop. The other options do not break out of the outer loop: 'continue outer;' would skip the current iteration of the outer loop but not break it, 'return;' would exit the method entirely, and 'break inner;' would break the inner loop but not the outer.

Answer

continue outer;

Answer

return;

Answer

break inner;

Question 8

What is the result of executing this code?

Accepted Answer

An exception is thrown at runtime.. The code attempts to call `findFirst()` on a `Stream<String>` that has already been consumed by a previous terminal operation (`forEach`). In Java, streams are single-use; after a terminal operation is executed, the stream is closed and cannot be reused. Any attempt to perform another terminal operation on the same stream throws an `IllegalStateException` at runtime.

Answer

bbc

Answer

Compilation error

Answer

baaabc

Question 9

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 10

Given a method that throws IOException, SQLException, and TimeoutException, a developer writes a catch block that rethrows the exception. Using Java 17, which exception types can the catch block declare in its throws clause if the rethrown exception is not modified?

Accepted Answer

Any single exception type that covers all caught exceptions.. In Java, when a catch block catches multiple exception types and rethrows the exception without modification, the compiler uses precise rethrow. This allows the throws clause to declare any exception type that is a supertype of all the caught exceptions, such as Exception (which is a common supertype of IOException, SQLException, and TimeoutException). Therefore, the developer does not need to list each checked exception individually; a single covering type is sufficient. Option D correctly states that any single exception type covering all caught exceptions can be declared.

Answer

The method must declare all checked exceptions individually.

Answer

Only the common superclass of the exceptions (Exception).

Answer

No throws clause is needed if the catch block logs and returns.

Question 11

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 12

Refer to the exhibit. What is the output?

Accepted Answer

30
20
10. The code uses a Deque (ArrayDeque) and calls push() to add elements, which adds them to the front of the deque (LIFO order). The for-each loop iterates from the head (first) to the tail (last), so it prints 30, 20, 10. Option B is correct because push() behaves like a stack, and iteration follows the deque's head-to-tail order.

Answer

10
20
30

Answer

20
30
10

Answer

30
10
20

Question 13

Given the following Java code:

```java
for (int i = 0; i <= 2; i++) {
    for (int j = i; j <= i+2; j++) {
        if (j <= 3) {
            System.out.print(j + " ");
        }
    }
}
```

What is the output?

Accepted Answer

0 1 2 1 2 3 2 3. The program uses nested for loops. The outer loop iterates i from 0 to 2 (inclusive). For each i, the inner loop iterates j from i to i+2 (inclusive), but due to a condition that prevents printing values greater than 3, the inner loop effectively prints j only up to 3. Thus, for i=0 it prints 0,1,2; for i=1 it prints 1,2,3; for i=2 it prints 2,3. Combined on one line, the output is '0 1 2 1 2 3 2 3', which corresponds to option B.

Answer

0 1 2 1 2 3 2 3 4

Answer

0 1 2 1 2 3 2 3 4 5

Answer

0 1 2 1 2 3 2 3 3 4

Question 14

A company wants to distribute a Java desktop application with a bundled JRE for end users who may not have Java installed. Which tool should they use?

Accepted Answer

jpackage. jpackage is the correct tool because it is specifically designed to package a Java application along with a bundled JRE into a native installer (e.g., .exe, .dmg, .deb) for distribution to end users who may not have Java installed. It uses the jlink tool internally to create a custom runtime image and then wraps it with platform-specific packaging tools, ensuring the application runs independently of any pre-installed JRE.

Answer

jlink

Answer

jar

Answer

jmod

Question 15

Which code will successfully produce an Optional<Integer> that contains the maximum value from a list of integers?

Accepted Answer

B and D both produce Optional.. Option A is correct because it states that options B and D both produce Optional. Option B uses list.stream().collect(Collectors.maxBy(Integer::compareTo)), which returns an Optional containing the maximum element. Option D uses list.stream().max(Integer::compareTo), which also returns an Optional with the maximum element. Option C, list.stream().max() without arguments, fails to compile because the Stream.max() method requires a Comparator. Therefore, A is the correct choice.

Answer

list.stream().collect(Collectors.maxBy(Integer::compareTo))

Answer

list.stream().max()

Answer

list.stream().max(Integer::compareTo)