1Z0-829 Controlling Program Flow — Timed 15 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