Control Flow and Loops practice questions

A developer writes a loop to iterate over an array of integers. The loop must sum all elements and stop early if the sum exceeds 100. Which control flow construct should be used?

Trap 1: while(true) { sum += arr[i]; i++; }

Incorrect because the while(true) loop lacks a termination condition, causing an infinite loop. It also does not prevent array index out of bounds.

Trap 2: do { sum += arr[i]; i++; } while(i<arr.length && sum <= 100);

Incorrect because the do-while loop checks the condition after executing the body, so if the sum exceeds 100 during the loop, it will still add the next element before checking the condition.

A
while(true) { sum += arr[i]; i++; }
Why wrong: Incorrect because the while(true) loop lacks a termination condition, causing an infinite loop. It also does not prevent array index out of bounds.
B
for(int i=0; i<arr.length; i++) { sum += arr[i]; if(sum > 100) break; }
Correct. It uses a standard for loop with an index, sums each element, and breaks when sum exceeds 100.
C
do { sum += arr[i]; i++; } while(i<arr.length && sum <= 100);
Why wrong: Incorrect because the do-while loop checks the condition after executing the body, so if the sum exceeds 100 during the loop, it will still add the next element before checking the condition.
D
for(int val : arr) { sum += val; if(sum > 100) break; }
Correct. The enhanced for loop iterates over each element. The break statement works inside it, stopping early when sum exceeds 100.

Question 2easymultiple choice

Which statement about the for-each loop in Java is true?

Trap 1: It cannot remove elements from a collection during iteration…

Correct. The for-each loop does not expose the iterator, so removing elements requires using an explicit iterator or collecting removals.

Trap 2: It can modify the array elements.

Incorrect. The for-each loop cannot modify the array elements by changing the loop variable; it only reads them.

Trap 3: It can iterate in reverse order.

Incorrect. The for-each loop iterates in the natural order of the collection or array; it does not support reverse iteration without additional logic.

A
It cannot remove elements from a collection during iteration without additional logic.
Why wrong: Correct. The for-each loop does not expose the iterator, so removing elements requires using an explicit iterator or collecting removals.
B
It can modify the array elements.
Why wrong: Incorrect. The for-each loop cannot modify the array elements by changing the loop variable; it only reads them.
C
It can iterate in reverse order.
Why wrong: Incorrect. The for-each loop iterates in the natural order of the collection or array; it does not support reverse iteration without additional logic.
D
It cannot be used with arrays.
Incorrect. The for-each loop can be used with arrays; it is a common misconception that it cannot.

Question 3hardmultiple choice

A developer implements a menu-driven application using a switch statement inside a do-while loop. The menu options are 1-4, and option 4 is supposed to exit the application. However, after selecting option 4, the menu is displayed again before the application exits. The code is structured as follows: do { displayMenu(); choice = scanner.nextInt(); switch(choice) { case 1: // process option 1 break; case 2: // process option 2 break; case 3: // process option 3 break; case 4: break; // intended to exit loop

}
} while(choice != 4);

The developer realizes that the break inside the switch only exits the switch, not the loop. What is the correct fix?

Trap 1: Use a continue statement instead of break

Continue would skip to the next iteration of the do-while loop, not exit it.

Trap 2: Replace the switch with an if-else chain

An if-else chain still needs a way to exit the outer loop; it doesn't solve the fundamental issue.

Trap 3: Set a flag variable to true and check it in the loop condition

While this could work, it adds unnecessary complexity when a labeled break is more direct.

A
Use a labeled break to exit the loop
A labeled break (e.g., 'break outer;') exits the outer loop directly, solving the problem cleanly.
B
Use a continue statement instead of break
Why wrong: Continue would skip to the next iteration of the do-while loop, not exit it.
C
Replace the switch with an if-else chain
Why wrong: An if-else chain still needs a way to exit the outer loop; it doesn't solve the fundamental issue.
D
Set a flag variable to true and check it in the loop condition
Why wrong: While this could work, it adds unnecessary complexity when a labeled break is more direct.

Question 4easymultiple choice

Which loop is guaranteed to execute its body at least once?

Trap 1: repeat-until loop

Not a Java construct.

Trap 2: while loop

May not execute if condition is false.

Trap 3: for loop

May not execute if condition is false.

A
repeat-until loop
Why wrong: Not a Java construct.
B
while loop
Why wrong: May not execute if condition is false.
C
do-while loop
Executes body then checks condition.
D
for loop
Why wrong: May not execute if condition is false.

Question 5hardmultiple choice

A developer needs to implement a menu-driven program that repeatedly displays options, reads input, and processes the choice until the user selects 'Exit'. Which loop structure and control flow is most appropriate?

Trap 1: for loop with break condition and nested if-else

Less readable and less natural for menu-driven programs.

Trap 2: for(;;) loop with if-else chain

Similar to while(true), less readable.

Trap 3: while(true) loop with if-else chain

Works but less readable than do-while with switch.

A
for loop with break condition and nested if-else
Why wrong: Less readable and less natural for menu-driven programs.
B
for(;;) loop with if-else chain
Why wrong: Similar to while(true), less readable.
C
do-while loop with switch statement
Ensures menu displays once, switch is clear for multiple options.
D
while(true) loop with if-else chain
Why wrong: Works but less readable than do-while with switch.

Question 6mediummultiple choice

What is the output of the following code?

int i = 0;
while (i < 5) {
    if (i == 3) {

i++; continue;

System.out.print(i + " "); i++;

Trap 1: 0 1 2 3

Missing 4 and includes 3.

Trap 2: 0 1 2 4 5

Loop stops at i<5, so 5 not printed.

Trap 3: 0 1 2 3 4

Does not skip 3.

A
0 1 2 4
Correctly skips 3 due to continue.
B
0 1 2 3
Why wrong: Missing 4 and includes 3.
C
0 1 2 4 5
Why wrong: Loop stops at i<5, so 5 not printed.
D
0 1 2 3 4
Why wrong: Does not skip 3.

Question 7hardmultiple choice

A developer writes: for(int i=0; i<10; i++) { if(i%2==0) continue; System.out.print(i); }. What is the output?

Trap 1: 0123456789

Ignores continue.

Trap 2: 02468

Prints even numbers, but continue skips even numbers.

Trap 3: 123456789

Includes 0 which is even.

A
0123456789
Why wrong: Ignores continue.
B
13579
Correctly prints odd numbers.
C
02468
Why wrong: Prints even numbers, but continue skips even numbers.
D
123456789
Why wrong: Includes 0 which is even.

Question 8mediummultiple choice

Which loop best suits a scenario where the number of iterations is unknown and depends on user input?

Trap 1: for loop

Best for known number of iterations.

Trap 2: for-each loop

Used for iterating over collections/elements.

Trap 3: do-while loop

Executes at least once, may not be appropriate if zero iterations possible.

A
for loop
Why wrong: Best for known number of iterations.
B
while loop
Condition checked before each iteration, suitable for unknown iterations.
C
for-each loop
Why wrong: Used for iterating over collections/elements.
D
do-while loop
Why wrong: Executes at least once, may not be appropriate if zero iterations possible.

Question 9mediummulti select

Which THREE statements are true about the switch statement in Java? (Choose three.)

Trap 1: It can be used with boolean expressions.

False. Switch cannot be used with boolean expressions; it works with int, char, short, byte, String, and enum types.

Trap 2: The default case must be placed at the end of the switch block.

False. The default case can be placed anywhere in the switch block; it does not have to be at the end.

A
It can be used with boolean expressions.
Why wrong: False. Switch cannot be used with boolean expressions; it works with int, char, short, byte, String, and enum types.
B
The default case must be placed at the end of the switch block.
Why wrong: False. The default case can be placed anywhere in the switch block; it does not have to be at the end.
C
Without a break statement, execution falls through to the next case.
True. Without a break, execution falls through to the next case (fall-through behavior).
D
The default case is optional.
True. The default case is optional; if no case matches and no default is present, the switch does nothing.
E
It can be used with String objects.
True. Since Java 7, switch can be used with String objects, comparing using String.equals().

Question 10hardmulti select

Which THREE statements are true about the break and continue statements in Java? (Choose three.)

Trap 1: The continue statement can be used to exit a loop entirely.

continue does not exit; it skips iteration.

Trap 2: The break statement cannot be used outside a loop.

break can be used in switch outside loop.

A
A labeled break can be used to exit an outer loop.
Correct: labeled break exits outer loop.
B
The continue statement skips the current iteration and proceeds to the next iteration.
Correct: continue moves to next iteration.
C
The break statement terminates the innermost enclosing loop or switch.
Correct: break exits the innermost loop/switch.
D
The continue statement can be used to exit a loop entirely.
Why wrong: continue does not exit; it skips iteration.
E
The break statement cannot be used outside a loop.
Why wrong: break can be used in switch outside loop.

Question 11mediummultiple choice

What is the output of the code?

```java

for (int i = 0; i < 5; i++) {
    if (i == 2) {

continue;

System.out.print(i + " ");

```

Exhibit

Refer to the exhibit.

for (int i = 0; i < 5; i++) {
    if (i == 2) {
        continue;
    }
    System.out.print(i + " ");
}

Trap 1: 0 1 2 3 4

Includes 2.

Trap 2: 1 3 4

Missing 0.

Trap 3: 0 1 2 3

Missing 4 and includes 2.

A
0 1 2 3 4
Why wrong: Includes 2.
B
1 3 4
Why wrong: Missing 0.
C
0 1 2 3
Why wrong: Missing 4 and includes 2.
D
0 1 3 4
Correct output.

Question 12hardmultiple choice

What is the value of sum printed?

int sum = 0;
for (int i = 0; i < 3; i++) {

sum = sum + i;

System.out.println(sum);

Exhibit

Refer to the exhibit.

int sum = 0;
for (int i = 1; i <= 10; i++) {
    if (i % 3 == 0) {
        break;
    }
    sum += i;
}
System.out.println(sum);

Trap 1: 6

Would be sum if break at i=4.

Trap 2: 0

Not correct.

Trap 3: 1

Only first iteration.

A
6
Why wrong: Would be sum if break at i=4.
B
0
Why wrong: Not correct.
C
3
The value 3 is printed because the code correctly implements an arithmetic operation or a loop that iterates precisely three times. For instance, if a `for` loop is initialised to `i = 0` and its condition is `i < 3`, the loop body will execute for `i = 0, 1, 2`, resulting in three increments to the `sum` variable. This satisfies the constraint of the loop's termination condition accurately determining the final accumulated value.
D
1
Why wrong: Only first iteration.

Question 13hardmultiple choice

You are tuning a real-time data processing application that reads sensor data from a queue. The system must process each sensor reading, but occasionally a reading is invalid (null) and should be skipped. The loop must run indefinitely until the application is shut down gracefully. The current implementation uses a while(true) loop with a break condition when a shutdown flag is set. However, the loop is consuming excessive CPU because it continuously polls the queue even when no data is available. You need to modify the loop to reduce CPU usage while still processing data efficiently. Which approach should you take?

Trap 1: Change the while(true) loop to a for loop that iterates a fixed…

Fixed iteration does not allow infinite processing.

Trap 2: Add a Thread.sleep(100) inside the loop to reduce polling frequency.

Sleep introduces latency and may not eliminate busy-waiting.

Trap 3: Use a do-while loop with a Thread.yield() call to give other…

yield() may not reduce CPU usage significantly.

A
Change the while(true) loop to a for loop that iterates a fixed number of times.
Why wrong: Fixed iteration does not allow infinite processing.
B
Replace the polling mechanism with a blocking queue that blocks until data is available.
Blocking queue blocks the thread, reducing CPU usage.
C
Add a Thread.sleep(100) inside the loop to reduce polling frequency.
Why wrong: Sleep introduces latency and may not eliminate busy-waiting.
D
Use a do-while loop with a Thread.yield() call to give other threads CPU time.
Why wrong: yield() may not reduce CPU usage significantly.

Question 14mediumdrag order

Arrange the steps to define a class with a main method in Java in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

5Step 5

Trap 1: Step 1: Declare the class, Step 2: Add other members, Step 3:…

This is incorrect because adding other members (e.g., fields or helper methods) before defining the main method is not invalid per se, but the logical order for a simple program is to first define the entry point. Doing it this way can cause confusion as the main method is not yet established.

Trap 2: Step 1: Define the main method, Step 2: Declare the class, Step 3:…

This is incorrect because you cannot define a method without first having a class to contain it. In Java, all methods must be inside a class, so the class declaration must come first.

Trap 3: Step 1: Declare the class, Step 2: Write code in main, Step 3:…

This is incorrect because you cannot write code inside a method before the method is defined. The method signature must be defined before writing its body.

A
Step 1: Declare the class, Step 2: Define the main method, Step 3: Add other members, Step 4: Write code in main, Step 5: Compile and run
This is the correct order because you must first declare a class to contain the code, then define the main method as the entry point, optionally add other class members, write the executable code inside main, and finally compile and run the program.
B
Step 1: Declare the class, Step 2: Add other members, Step 3: Define the main method, Step 4: Write code in main, Step 5: Compile and run
Why wrong: This is incorrect because adding other members (e.g., fields or helper methods) before defining the main method is not invalid per se, but the logical order for a simple program is to first define the entry point. Doing it this way can cause confusion as the main method is not yet established.
C
Step 1: Define the main method, Step 2: Declare the class, Step 3: Add other members, Step 4: Write code in main, Step 5: Compile and run
Why wrong: This is incorrect because you cannot define a method without first having a class to contain it. In Java, all methods must be inside a class, so the class declaration must come first.
D
Step 1: Declare the class, Step 2: Write code in main, Step 3: Define the main method, Step 4: Add other members, Step 5: Compile and run
Why wrong: This is incorrect because you cannot write code inside a method before the method is defined. The method signature must be defined before writing its body.

Question 15mediummatching

Match each Java operator to its description.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Increment by 1

Modulo (remainder) operator

Logical AND (short-circuit)

Checks if an object is of a certain type

Ternary conditional operator

Trap 1: !=: Used to assign a value to a variable

Incorrect. The != operator is used for inequality comparison, not assignment. Assignment is done with =.

Trap 2: instanceof: Used to compare two primitive values

Incorrect. instanceof checks if an object is an instance of a specific class, not for comparing primitive values.

Trap 3: ?:: Used to perform a logical OR operation

Incorrect. The ternary operator ?: is used for conditional expression, not logical OR. Logical OR is ||.

A
==: Compares two values for equality
The == operator is used for equality comparison between two values.
B
&&: Returns true if both operands are true
The && operator is the logical AND operator, which returns true only if both operands are true.
C
!=: Used to assign a value to a variable
Why wrong: Incorrect. The != operator is used for inequality comparison, not assignment. Assignment is done with =.
D
instanceof: Used to compare two primitive values
Why wrong: Incorrect. instanceof checks if an object is an instance of a specific class, not for comparing primitive values.
E
?:: Used to perform a logical OR operation
Why wrong: Incorrect. The ternary operator ?: is used for conditional expression, not logical OR. Logical OR is ||.

Question 16easymultiple choice

A developer needs to iterate over an array of integers and compute the sum of its elements. Which loop construct is most appropriate for this task?

Trap 1: while loop

Requires manual index incrementation, more error-prone.

Trap 2: switch statement

Switch is for conditional branching, not iteration.

Trap 3: do-while loop

Not designed for simple iteration; need index.

A
while loop
Why wrong: Requires manual index incrementation, more error-prone.
B
Enhanced for loop
Simplest and clearest for iterating over all elements.
C
switch statement
Why wrong: Switch is for conditional branching, not iteration.
D
do-while loop
Why wrong: Not designed for simple iteration; need index.

Question 17mediummultiple choice

A programmer writes a switch statement to handle different cases. The code compiles and runs, but the output is unexpected: 'A' prints when the input is 'B'. Which is the most likely cause?

Trap 1: The switch variable type is char but should be String.

Char is valid for switch; type mismatch would cause compile error, not fall-through.

Trap 2: The switch statement is missing a default case.

Missing default does not cause fall-through.

Trap 3: The default case is executed instead of the matched case.

Default runs only when no match, but output shows a different matched case.

A
A break statement is missing after the case 'B'.
Fall-through from case 'B' to case 'A' occurs without break.
B
The switch variable type is char but should be String.
Why wrong: Char is valid for switch; type mismatch would cause compile error, not fall-through.
C
The switch statement is missing a default case.
Why wrong: Missing default does not cause fall-through.
D
The default case is executed instead of the matched case.
Why wrong: Default runs only when no match, but output shows a different matched case.

Question 18hardmultiple choice

In a nested loop structure, a developer wants to exit completely from the outer loop when a certain condition is met inside the inner loop. Which approach is correct?

Trap 1: Use a return statement within the inner loop.

Exits the entire method, which may be overly broad.

Trap 2: Use a continue statement with a label.

Continue only skips current iteration of the labeled loop, does not exit.

Trap 3: Use a break statement inside the inner loop.

Breaks only the inner loop, outer loop continues.

A
Use a return statement within the inner loop.
Why wrong: Exits the entire method, which may be overly broad.
B
Use a continue statement with a label.
Why wrong: Continue only skips current iteration of the labeled loop, does not exit.
C
Use a labeled break statement (e.g., break outerLabel;).
Exits the outer loop immediately.
D
Use a break statement inside the inner loop.
Why wrong: Breaks only the inner loop, outer loop continues.

Question 19easymulti select

Which THREE of the following are valid loop constructs in Java?

Trap 1: switch statement

Incorrect: The switch statement is a conditional branching construct, not a loop.

Trap 2: if statement

Incorrect: The if statement is a conditional construct, not a loop.

A
while loop
Correct: The while loop is a standard loop construct in Java.
B
for loop
Correct: The for loop is a standard loop construct in Java.
C
switch statement
Why wrong: Incorrect: The switch statement is a conditional branching construct, not a loop.
D
if statement
Why wrong: Incorrect: The if statement is a conditional construct, not a loop.
E
do-while loop
Correct: The do-while loop is a valid loop construct that executes its body at least once.

Question 20mediummulti select

Which THREE of the following are valid types that can be used as a switch expression in Java (as of Java 8)?

Trap 1: long

long is not allowed; only int and smaller integer types.

Trap 2: boolean

boolean is not allowed in switch.

A
long
Why wrong: long is not allowed; only int and smaller integer types.
B
String
String is valid since Java 7.
C
char
char is a valid switch type.
D
int
int is a valid switch type.
E
boolean
Why wrong: boolean is not allowed in switch.