Scenario practice questions

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

A team is implementing a search algorithm that iterates over an array of integers. The loop should stop as soon as the target value is found. Which loop construct is most appropriate?

Trap 1: While loop with a flag variable

A while loop works but a for loop is more idiomatic for array iteration.

Trap 2: Enhanced for loop with continue

continue skips to next iteration, not suitable for early exit.

Trap 3: Do-while loop

Do-while always executes at least once, which may be redundant.

A
While loop with a flag variable
Why wrong: A while loop works but a for loop is more idiomatic for array iteration.
B
Enhanced for loop with continue
Why wrong: continue skips to next iteration, not suitable for early exit.
C
Do-while loop
Why wrong: Do-while always executes at least once, which may be redundant.
D
For loop with break
A for loop with break is the most direct way to iterate and stop on condition.

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

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.

Question 7hardmultiple 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 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.