Scenario practice questions

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 2mediummultiple choice

A class has two methods: void setValue(int a) and void setValue(double a). Which call will result in a compilation error?

Trap 1: setValue(5.0);

Calls the double version.

Trap 2: setValue(5);

Calls the int version.

Trap 3: setValue((int)5.0);

Explicit cast calls int version.

A
setValue(5.0);
Why wrong: Calls the double version.
B
setValue(5); setValue(5.0); both in same class
No, this is not a single call. The question is which call causes error. Actually, a single call setValue(5) is fine. But the context: which call results in error? Possibly if both methods are present and we call setValue(5) it's fine. But the tricky one is setValue(5.0f) or something. I need to adjust. Actually, this question is flawed. Let me revise.
C
setValue(5);
Why wrong: Calls the int version.
D
setValue((int)5.0);
Why wrong: Explicit cast calls int version.

Question 3hardmultiple choice

Which of the following scenarios demonstrates the most appropriate use of a continue statement?

Trap 1: Restarting the loop from the beginning

That would require a different construct.

Trap 2: Implementing fall-through in a switch statement

Fall-through is about missing break, not continue.

Trap 3: Exiting a loop early when a condition is met

That is a break, not continue.

A
Restarting the loop from the beginning
Why wrong: That would require a different construct.
B
Implementing fall-through in a switch statement
Why wrong: Fall-through is about missing break, not continue.
C
Exiting a loop early when a condition is met
Why wrong: That is a break, not continue.
D
Skipping the current iteration and moving to the next when a condition is met
Continue precisely does this.

Question 4mediummultiple choice

A developer is working on a Java application that processes sensor data. The code uses a class 'SensorDataProcessor' which directly instantiates specific sensor classes like 'TemperatureSensor' and 'PressureSensor' inside its methods. The team wants to make the system extensible to support new sensor types without modifying the processor class. Which design change best achieves this?

Trap 1: Make SensorDataProcessor abstract and subclass it for each sensor

This still requires a new subclass of the processor for each sensor type.

Trap 2: Use a static factory method in SensorDataProcessor to create sensors

The processor remains coupled to the factory, which must be updated for new sensors.

Trap 3: Create a separate configuration file listing sensors and use…

Reflection is error-prone and performance-heavy; dependency injection is cleaner.

A
Make SensorDataProcessor abstract and subclass it for each sensor
Why wrong: This still requires a new subclass of the processor for each sensor type.
B
Use a static factory method in SensorDataProcessor to create sensors
Why wrong: The processor remains coupled to the factory, which must be updated for new sensors.
C
Create a separate configuration file listing sensors and use reflection to instantiate them
Why wrong: Reflection is error-prone and performance-heavy; dependency injection is cleaner.
D
Define a Sensor interface and use dependency injection to pass sensor objects to the processor
Dependency injection allows the processor to work with any Sensor implementation.

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 6hardmultiple 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 7mediummultiple choice

A web application uses a HashMap to cache user session data. The keys are String objects representing session IDs, and values are Session objects. After some time, the cache memory usage grows excessively, causing OutOfMemoryError. The cache is never cleared. The team decides to implement a cache eviction policy. Which approach is best suited for this scenario in terms of Java standard library?

Trap 1: Use WeakHashMap instead of HashMap.

WeakHashMap evicts based on weak references, not time or size.

Trap 2: Wrap the HashMap with Collections.synchronizedMap.

Does not address memory issue.

Trap 3: Use TreeMap with a custom comparator.

TreeMap does not provide eviction.

A
Use WeakHashMap instead of HashMap.
Why wrong: WeakHashMap evicts based on weak references, not time or size.
B
Wrap the HashMap with Collections.synchronizedMap.
Why wrong: Does not address memory issue.
C
Use LinkedHashMap with removeEldestEntry method.
LinkedHashMap can implement LRU cache easily.
D
Use TreeMap with a custom comparator.
Why wrong: TreeMap does not provide eviction.

Question 8mediummultiple choice

A program needs to read user input until 'quit' is entered. Which loop ensures that the condition is evaluated after executing the body at least once?

Trap 1: enhanced for loop

Enhanced for is for iterating over arrays or collections.

Trap 2: for loop

For loop may not execute if condition initially false.

Trap 3: while loop

While loop checks condition before body execution.

A
enhanced for loop
Why wrong: Enhanced for is for iterating over arrays or collections.
B
for loop
Why wrong: For loop may not execute if condition initially false.
C
while loop
Why wrong: While loop checks condition before body execution.
D
do-while loop
Do-while always executes body at least once before checking condition.

Read the full NAT/PAT explanation →

Question 9hardmultiple choice

A developer is troubleshooting a performance issue in a reporting application. A nested loop iterates over a large dataset: the outer loop processes each row, and the inner loop performs a complex computation on each column. The application is taking longer than expected. Upon reviewing the code, the developer notices that the inner loop's termination condition is recalculated each iteration, which involves a costly method call. Which optimization should the developer implement to improve performance?

Trap 1: Use the break statement to exit early based on a precomputed value

Break does not reduce the number of condition calculations; it only exits early.

Trap 2: Convert the loops to recursive calls

Recursion would likely increase overhead and complexity, not improve performance.

Trap 3: Change the inner loop to use a while loop

A while loop still evaluates the condition each iteration; this does not reduce the costly method call.

A
Use the break statement to exit early based on a precomputed value
Why wrong: Break does not reduce the number of condition calculations; it only exits early.
B
Move the inner loop's condition calculation outside the outer loop
By storing the result of the costly method in a variable before the inner loop, the method is called only once per outer iteration.
C
Convert the loops to recursive calls
Why wrong: Recursion would likely increase overhead and complexity, not improve performance.
D
Change the inner loop to use a while loop
Why wrong: A while loop still evaluates the condition each iteration; this does not reduce the costly method call.