1Z0-829 Controlling Program Flow — Timed 50 Questions

Question 1

What is the output?

```java
int x = 10;
do {
    System.out.print(x);
} while (x-- > 10);
```

Accepted Answer

10. 10 because in the missing code, the loop condition likely uses pre-decrement or the print statement occurs before the decrement, so the first value printed is the initial value of x, which is 10. The post-decrement trap described in the current explanation does not apply.

Answer

9

Answer

15

Answer

6

Question 2

You are developing a high-frequency trading application that processes a stream of market data ticks. Each tick is represented by a Tick object with fields: long timestamp, String symbol, double price, int volume. Ticks arrive in real-time and must be processed in order. A bug is reported: the application occasionally processes a tick out of order, causing incorrect trade decisions. The processing logic uses a while loop to read from a blocking queue and process each tick. The code is: BlockingQueue queue = new LinkedBlockingQueue<>(); while (true) { Tick tick = queue.take(); process(tick); } After investigation, you find that the queue is fed by multiple producer threads that sometimes reorder ticks due to network delays. Which course of action best ensures ticks are processed in the correct chronological order without sacrificing throughput?

Accepted Answer

Replace LinkedBlockingQueue with a PriorityBlockingQueue that orders by timestamp.. PriorityBlockingQueue maintains elements in natural order (or by a provided Comparator), so ticks are automatically ordered by timestamp when inserted. This ensures the consumer always processes the chronologically earliest tick first, even if producers add them out of order, without requiring additional sorting or blocking.

Answer

Use a SynchronousQueue and have producers wait for the consumer to acknowledge.

Answer

After taking from the queue, sort a batch of ticks before processing.

Answer

Add a delay before processing to allow out-of-order ticks to arrive.

Question 3

Which THREE statements about the switch statement in Java are correct?

Accepted Answer

The default case can be placed anywhere within the switch block.. Option A is correct because the default label is not required to be last; it may appear anywhere in the switch block, and it is only selected when no case label matches (or when no case matches and no default exists, the switch does nothing). Option D is correct because a case label must be a constant expression, and a final variable initialized with a compile-time constant expression (e.g., static final int X = 5;) qualifies as a constant expression usable as a case label. Option E is correct because Java's switch supports int (and the byte, short, char, and int wrapper types via unboxing), char, String, and enum types, in addition to the newer switch expressions/patterns. Option B is not correct because case values must be compile-time constant expressions, not runtime expressions. Option C is not correct because break is optional; without it, control falls through to subsequent case labels, and break is only needed to prevent fall-through.

Answer

Case values can be runtime expressions.

Answer

A break statement is mandatory after each case block.

Question 4

A Java application processes a list of orders. Each order has a status: NEW, PROCESSING, SHIPPED, or DELIVERED. The code must print a message based on the status:
- If NEW: "Order received"
- If PROCESSING: "Order in progress"
- If SHIPPED: "Order shipped"
- If DELIVERED: "Order delivered"
- For any other status: "Unknown status"

The developer writes the following code using a switch expression:

String message = switch (status) {
    case NEW -> "Order received";
    case PROCESSING -> "Order in progress";
    case SHIPPED -> "Order shipped";
    case DELIVERED -> "Order delivered";
    default -> "Unknown status";
};
System.out.println(message);

What is the correct course of action to ensure the code compiles and runs correctly?

Accepted Answer

No change needed; the code compiles and runs as expected.. The switch expression shown is syntactically valid and complete. It uses the arrow syntax with all enum constants covered and includes a default branch to handle any other status, so it compiles and runs as expected. Switch expressions can yield values and work with enum types, making the code correct as written.

Answer

Add a default branch to handle any other status.

Answer

Use if-else if statements because switch cannot be used with enum types.

Answer

Change the switch expression to a switch statement because switch expressions cannot yield values.

Question 5

A Java developer is writing a batch processing application that reads records from a database and processes them. The processing must continue even if some records cause exceptions (e.g., data conversion errors). However, the application must log each failed record and its error, then continue with the next record. The developer uses a for loop to iterate over a list of records. Inside the loop, a try-catch block wraps the processing logic. After implementing, the developer notices that when an exception occurs, the loop terminates prematurely instead of continuing. The code structure is:

List<Record> records = fetchRecords();
for (Record rec : records) {
    try {
        process(rec);
    } catch (Exception e) {
        log.error("Failed to process: " + rec.getId(), e);
    }
}

What is the most likely reason for the premature termination?

Accepted Answer

The process() method throws an Error instead of an Exception.. The code catches `Exception`, but `Error` (and its subclasses like `OutOfMemoryError`, `StackOverflowError`, or custom `Error` types) are not subclasses of `Exception`. In Java, `Throwable` has two main branches: `Exception` (including `RuntimeException`) and `Error`. Since `Error` is not caught by `catch (Exception e)`, it propagates up and terminates the loop. This is the most likely reason for premature termination because the developer assumed all failures would be `Exception` types.

Answer

The records list contains null elements, causing a NullPointerException that is not caught.

Answer

The log.error() method itself throws an unchecked exception that is not caught.

Answer

The try-catch block is incorrectly placed inside the for loop, causing the loop to break on any exception.

Question 6

Given the following code:

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

What is the output?

Accepted Answer

0-0 0-1 0-2 2-0 2-1 2-2. The code uses a labeled continue statement 'continue outer' that, when i equals 1, skips the entire inner loop for that iteration. Thus, no output is produced when i=1. The output consists of the pairs from i=0 (j=0,1,2) and i=2 (j=0,1,2), resulting in '0 0 0 1 0 2 2 0 2 1 2 2', which is correctly represented in option D.

Answer

0-0 0-1 0-2 1-0 2-0 2-1 2-2

Answer

0-0 0-1 0-2 1-0 1-1 1-2 2-0 2-1 2-2

Answer

0-0 0-1 0-2 2-0 2-1

Question 7

Which THREE statements are true about the enhanced for loop in Java?

Accepted Answer

The enhanced for loop internally uses an iterator for collections.. Option B is correct because for any object implementing Iterable, the enhanced for loop is compiled into an Iterator-based traversal (calling iterator(), hasNext(), and next()), which is why it works with collections. Option C is correct because the enhanced for loop also supports arrays, compiling to an index-based loop over the array's length. Option D is correct because the loop variable is a local copy of each element; assigning to it only changes that local variable and does not affect the underlying array or collection, so it cannot be used to modify elements in place. Option A is wrong because modifying the underlying collection during iteration typically throws a ConcurrentModificationException (fail-fast behavior), not continuing without error. Option E is wrong because the loop variable is not required to be declared final; it may be implicitly effectively final in usage but the header does not mandate the final keyword.

Answer

If the underlying collection is modified during iteration, the loop will continue without error.

Answer

The loop variable must be declared final in the loop header.

Question 8

Which TWO of the following are valid forms of the switch statement/expression in Java?

Accepted Answer

switch(x) { case 1: System.out.println("one"); break; }. Option B is correct because it is the classic Java switch statement syntax: a colon-labeled case with statements and a break to prevent fall-through, which has been valid since Java 1.0. Option C is correct because it is a valid switch expression: the arrow form (case 1 -> "one") is a switch rule, the result is assigned to a String, and a default arm is present, which is required for exhaustive switch expressions. Option A is invalid because a switch statement using arrow labels cannot have a bare expression as the arm body; it must be a statement, block, or throw, so case 1 -> "one"; does not compile. Option D is invalid because Java has no break with a value syntax; switch expressions use yield, not break "one". Option E is invalid because yield may only appear inside a switch expression, not in a switch statement, and the switch here is not used as an expression.

Answer

switch(x) { case 1 -> "one"; }

Answer

String r = switch(x) { case 1: break "one"; };

Answer

switch(x) { case 1: yield "one"; }

Question 9

Which change fixes the exception?

Accepted Answer

Change line 4 to: for (int i = 0; i < arr.length; i++). It changes the loop to start at index 0 and continue while i < arr.length, which correctly iterates over all valid indices (0 to arr.length-1). The original code likely used i <= arr.length, causing an ArrayIndexOutOfBoundsException when accessing arr[i] at i = arr.length. By using i < arr.length, the loop stops before reaching the out-of-bounds index.

Answer

Change line 4 to: for (int i = 1; i <= arr.length; i++)

Answer

Change line 4 to: for (int i = 0; i <= arr.length-1; i++)

Answer

Change line 5 to: System.out.println(arr[i-1]);

Question 10

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 11

Which two statements about the break statement are true?

Accepted Answer

break without a label terminates the innermost loop or switch.. Option B 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 E is correct because break is a valid statement inside a switch, where it terminates the switch block and prevents fall-through to subsequent case labels. Option A is not correct as stated because break cannot appear merely inside an if; it must be lexically enclosed by a loop or switch, so an if alone does not make break legal. Option C is incorrect because break is also permitted inside switch statements, not only loops. Option D is incorrect because a labeled break terminates the matching labeled statement (a loop or block with that label), not the outermost matching loop or switch.

Answer

break can be used inside an if statement.

Answer

break can only be used inside a loop.

Answer

break with a label terminates the outermost matching loop or switch.

Question 12

Which three of the following are valid case values in a traditional switch statement (non-pattern)?

Accepted Answer

42. Option A (42) is valid because a traditional switch case can use a compile-time constant int literal, and int is one of the primitive types historically permitted in switch statements. Option D (Monday, an enum constant) is valid because enum constants are compile-time constants and switch on enum types is explicitly supported. Option E ("hello") is valid because String is supported in switch statements since Java 7, provided the case label is a constant String expression. Option B (true) is not valid because boolean is not an allowed switch selector type, so a boolean case label cannot appear. Option C (3.14) is not valid because floating-point types (float/double) are not permitted as switch selector types, so a double literal cannot be a case value.

Answer

true

Answer

3.14

Question 13

```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 14

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 15

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 16

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 17

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 18

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 19

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 20

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.