1Z0-829 Controlling Program Flow Practice Test 2 — 15 Questions

Question 1

Which statement is correct about the following switch expression? String result = switch(day) { case MONDAY, TUESDAY -> "weekday"; case WEDNESDAY -> "midweek"; default -> "other"; };

Accepted Answer

The switch expression must be terminated with a semicolon.. Switch expressions in Java must be terminated with a semicolon, as they produce a value that is assigned to a variable. The given code uses the arrow syntax (->) and assigns the result to a String variable, so a semicolon is required at the end of the entire switch expression.

Answer

The switch expression is not allowed with a colon.

Answer

The default branch is optional.

Answer

The arrow operator requires a yield statement.

Question 2

A developer has a method that contains a try-catch-finally block inside a while loop. The try block throws a checked exception that is caught by the catch block. The catch block throws a new runtime exception. What is the behavior?

Accepted Answer

The loop terminates immediately, and the runtime exception propagates.. When a checked exception is caught and the catch block throws a new runtime exception, the finally block executes before the runtime exception propagates. Since the runtime exception is thrown from within the catch block (inside the while loop), it immediately terminates the loop and propagates up the call stack. Option B is correct because the loop does not continue; the runtime exception is thrown after the finally block completes.

Answer

The loop continues after the finally block, and the runtime exception is thrown after the loop.

Answer

The loop continues after the catch block, and the runtime exception is not propagated.

Answer

The loop continues after the finally block, and the runtime exception is suppressed.

Question 3

Which two of the following are valid ways to exit a loop in Java?

Accepted Answer

label break. Option C (break) is correct because the unlabeled break statement immediately terminates the innermost enclosing loop (for, while, or do-while) and transfers control to the statement following that loop. Option A (label break) is correct because a labeled break such as `break outer;` terminates the loop (or block) identified by the matching label, allowing exit from an outer loop from within a nested loop. Option B (continue) is not a way to exit a loop; it skips the remainder of the current iteration and proceeds to the next iteration, so the loop keeps running. Option D (System.exit(0)) terminates the entire Java Virtual Machine rather than exiting just the loop, so it is not a loop-exit construct. Option E (throw new Exception()) does not exit a loop normally; it aborts the method by propagating an exception unless the exception is caught, which is not the same as exiting the loop.

Answer

continue

Answer

System.exit(0)

Answer

throw new Exception()

Question 4

Refer to the exhibit. The exhibit shows a stack trace from a Java application. Which line in the code caused the NullPointerException?

Accepted Answer

Line 8: int len = s.length();. The NullPointerException occurs when invoking the `length()` method on a null reference. In the stack trace, the exception is thrown at line 8, where `s.length()` is called, but `s` has not been assigned a non-null value (it is null by default if declared as a field, or uninitialized locally). The JVM throws NullPointerException when any instance method is called on a null object reference.

Answer

Line 10: System.out.println(len);

Answer

Line 12: String s = "hello";

Answer

Line 5: int x = 10;

Question 5

In a large enterprise application, a concurrent caching system is implemented using a ConcurrentHashMap that is accessed by multiple threads concurrently. The cache performs atomic operations on individual keys, but some operations require updates on multiple keys. To ensure consistency, the code acquires intrinsic locks on the keys using synchronized blocks. Over time, the system has been experiencing intermittent deadlocks. During post-mortem analysis, it was found that thread A holds a lock on key X and is waiting for key Y, while thread B holds a lock on key Y and is waiting for key X. The development team needs to redesign the locking strategy to eliminate these deadlocks while maintaining high throughput and minimizing code changes. They consider the following proposals: replacing ConcurrentHashMap with Collections.synchronizedMap, using a single ReentrantLock for all cache operations, always acquiring locks on keys in a consistent global order, or using a Lock with tryLock and a timeout and releasing all locks if timeout expires. Based on best practices in concurrent programming and considering the requirements to avoid deadlocks and maintain performance, which approach should they choose?

Accepted Answer

Use a Lock with tryLock and a timeout, and release all locks if timeout expires.. Using tryLock with a timeout allows threads to back off and release all acquired locks if they cannot obtain all required locks within a specified time, which breaks the circular wait condition that causes deadlocks. This approach maintains high throughput by avoiding coarse-grained locking and minimizes code changes by only modifying the lock acquisition logic, not the underlying ConcurrentHashMap structure.

Answer

Use a single ReentrantLock for all cache operations.

Answer

Replace ConcurrentHashMap with Collections.synchronizedMap.

Answer

Always acquire locks on keys in a consistent global order.

Question 6

Given the following switch expression with colon syntax, what is the result when code equals 2? int val = switch(code) { case 1: yield 10; case 2: yield 20; default: yield 30; };

Accepted Answer

20. When code equals 2, the switch expression matches case 2: and executes the yield 20; statement, which returns 20 as the value assigned to val. The colon syntax with yield is valid in Java 14+ switch expressions, and each case must yield a value.

Answer

10

Answer

30

Answer

Compilation error

Question 7

A developer is implementing a method that processes a collection of objects. The objects are instances of various classes that implement a common interface. The developer wants to use a switch expression to perform different actions based on the runtime type of each object. Which approach is correct?

Accepted Answer

Use a switch expression with pattern matching without a default case if all possible types are covered.. Java 17+ switch expressions with pattern matching allow exhaustive type coverage without a default case when all possible subtypes of the sealed interface or hierarchy are explicitly listed. This ensures compile-time safety and eliminates the need for a default branch, aligning with the principle of exhaustive pattern matching.

Answer

Use a series of if-else statements with instanceof.

Answer

Use a switch expression with pattern matching and a default case.

Answer

Use a traditional switch statement with instanceof checks and casting.

Question 8

Which TWO statements about the break and continue statements in Java are correct?

Accepted Answer

The break statement without a label always terminates the innermost enclosing loop or switch.. Option A is correct because an unlabeled break immediately exits the innermost enclosing loop (for, while, do-while) or switch statement, transferring control to the statement following that construct. Option B is correct because continue is valid in all three loop forms — for, while, and do-while — where it skips the remainder of the current iteration and proceeds to the loop's update/condition handling. Option C is wrong because continue is not permitted in a switch unless the switch is itself inside a loop; it applies to the enclosing loop, not the switch body. Option D is wrong because break can also be used with a label to exit any labeled block, not only loops and switches. Option E is wrong because in a for loop, continue does evaluate the update expression and then the condition, so it does not bypass reevaluation of the loop condition.

Answer

The continue statement can be used inside a switch statement to skip the rest of the switch body.

Answer

The break statement can be used only inside loops and switch statements.

Answer

The continue statement without a label skips the current iteration and proceeds to the next iteration without reevaluating the loop condition.

Question 9

A financial trading system uses a Java application to process market data. The core algorithm uses nested loops to compare price arrays. The developer uses a labeled continue statement to skip certain combinations. After a code review, the team suspects the algorithm has a bug that causes incorrect results. The developer writes a unit test and discovers that the labeled continue sometimes skips more iterations than intended. The code is: outer: for (int i = 0; i < prices1.length; i++) { for (int j = 0; j < prices2.length; j++) { if (prices1[i] < prices2[j]) continue outer; // process combination } } The developer intended that if any price in prices1 is less than a price in prices2, the entire row (i) should be skipped. However, the algorithm skips rows even when the condition is not met for all j. What is the most likely cause?

Accepted Answer

The condition for continuing is not correctly evaluated.. The developer intended to skip the i-th row only if for every j, prices1[i] < prices2[j]. However, the condition currently uses an inequality that triggers on any j, causing rows to be skipped prematurely. The bug is that the condition is not correctly evaluating the intended logic; it should check that the condition holds for all j, not just one. Therefore, the correct answer is C.

Answer

A break statement is missing after processing a combination.

Answer

The label outer is placed on the inner loop, not the outer loop.

Answer

The continue outer statement should be a break outer.

Question 10

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 11

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 12

A developer is implementing a countdown timer using a while loop. The code must print numbers from 5 down to 1, each on a new line, and then print "Liftoff!". They write the following code:

```java
int count = 5;
while (count > 0) {
    System.out.println(count);
    count--;
}
System.out.println("Liftoff!");
```

However, when they run the program, it prints numbers from 5 down to 1 and then "Liftoff!", but they intended to also print "Liftoff!" only if the countdown completed without interruption. They decide to modify the loop to allow the user to interrupt the countdown by entering 'q' at any time. Which of the following modifications correctly implements the interrupt feature using a `break` statement?

Accepted Answer

Add a check for user input inside the loop. If input is 'q', set a boolean flag `interrupted` to true and use `break` to exit the loop. After the loop, print "Liftoff!" only if `interrupted` is false.. To interrupt a loop and conditionally execute code afterward, a `break` statement alone is insufficient because it only exits the loop. A boolean flag set before breaking allows the code after the loop to determine whether the loop completed normally. This pattern is common when a loop can terminate early due to an external condition. The other options either print unconditionally or fail to exit the loop.

Answer

Add a check for user input inside the loop and use `break` to exit the loop if the input is 'q', then print "Liftoff!" after the loop.

Answer

Replace the while loop with a do-while loop and use `break` when input is 'q'. After the loop, print "Liftoff!" unconditionally.

Answer

Add a check for user input inside the loop and use `continue` to skip the rest of the loop body if the input is 'q', allowing the countdown to continue.

Question 13

A grid-rendering routine must iterate over a two-dimensional array and stop scanning entirely once it finds a cell whose value is negative. The developer writes:

```java
int[][] grid = {{1, 2, 3}, {4, -5, 6}, {7, 8, 9}};
int sum = 0;
outer:
for (int[] row : grid) {
    for (int cell : row) {
        if (cell < 0) break outer;
        sum += cell;
    }
}
System.out.println(sum);
```
What is printed?

Accepted Answer

7. A labeled break exits the loop carrying the matching label, not merely the innermost loop. Because outer labels the row loop, encountering -5 terminates both loops immediately. The cells 1, 2, 3, and 4 have already been added, so the printed sum is 7.

Answer

10

Answer

2

Answer

45