1Z0-811 Practice Test 36 — 15 Questions

Question 1

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?

Accepted Answer

Use a labeled break to exit the loop. Option D is correct because using a labeled break can directly exit the outer do-while loop. Option A is wrong because an if-else chain would not solve the loop exit issue; it would still require a mechanism to exit the outer loop. Option B is wrong because continue would skip to the next iteration, not exit. Option C is wrong because setting a flag is unnecessary when labeled break provides a direct solution.

Answer

Use a continue statement instead of break

Answer

Replace the switch with an if-else chain

Answer

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

Question 2

A developer is implementing a login system where users enter a password that is then hashed using SHA-256. The system stores the hash as a String in the database. On login, the entered password is hashed and compared to the stored hash using the == operator. Occasionally, valid users are denied access, even though the hashes are identical when printed. The developer has confirmed that the hash algorithm is correctly implemented and that the stored hash is exactly the same string as the computed hash. What is the most likely cause and correct fix?

Accepted Answer

Change the comparison from == to equals().. The == operator compares object references, not string content. Even if the two hash strings are logically equal, they are different String objects in memory, so == returns false. The correct fix is to use the equals() method (or equalsIgnoreCase() for case-insensitive comparison, but hashes are case-sensitive). Option A directly fixes the issue. Option B (intern()) is not standard. Option C (compareTo()) could work but equals() is idiomatic. Option D (hashCode()) compares integers, not strings.

Answer

Use hashCode() to compare integer representations.

Answer

Call intern() on both hash strings before using ==.

Answer

Use compareTo() which returns 0 if equal.

Question 3

A financial trading application processes a batch of 10 million trade transactions every night. Each transaction is a String containing trade details such as ID, symbol, quantity, and price. The current implementation uses string concatenation with the += operator in a loop to build a summary report string. The application frequently runs out of memory and takes hours to complete. The server has 16 GB of RAM and runs Java 11. The code cannot be restructured significantly due to regulatory requirements, but performance improvements are allowed. Which course of action will most effectively resolve the performance and memory issues?

Accepted Answer

Replace the String concatenation with StringBuilder.. String concatenation using += inside a loop creates many intermediate String objects, leading to memory waste and slowness. StringBuilder is mutable and designed for efficient string building without creating multiple intermediate objects. Option C is the optimal fix. Option A (heap increase) only delays the problem. Option B (StringBuffer) is thread-safe but slower due to synchronization, unnecessary in a single-threaded context. Option D (using intern()) does not improve efficiency and can harm performance.

Answer

Call intern() on the concatenated result at each iteration.

Answer

Increase the JVM heap size to 32 GB to accommodate the temporary string objects.

Answer

Replace the String concatenation with StringBuffer.

Question 4

A stock trading system calculates daily profit using an int variable. During periods of high volatility, the profit can exceed Integer.MAX_VALUE (2,147,483,647). When this happens, the profit value wraps around to a negative number, leading to incorrect reporting. The lead developer wants to detect the overflow and throw an ArithmeticException rather than silently producing wrong results. The code cannot use long or BigInteger due to legacy constraints. Which approach should be taken?

Accepted Answer

Use Math.addExact() for the addition and catch or let the exception propagate.. Math.addExact() performs integer addition with overflow detection, throwing an ArithmeticException if the result overflows. Option A directly addresses the requirement. Option B (BigInteger) changes the data type, which is ruled out. Option C (casting to long before addition) changes the type, also not allowed. Option D (bitwise operators) is complex and error-prone, and does not inherently detect overflow.

Answer

Use bitwise AND with a mask to detect overflow.

Answer

Cast the operands to long before addition and then cast back to int.

Answer

Use BigInteger for the calculation and convert back to int.

Question 5

A scientific application performs calculations with double precision. A specific formula divides two double values: result = a / b; where a and b are calculated from sensor readings. The result is expected to be at most 10 decimal digits of precision. However, the output often shows small rounding errors, e.g., 0.1 + 0.2 = 0.30000000000000004. The application must meet strict accuracy requirements and cannot tolerate these small errors. Which strategy should be used to achieve exact decimal representation?

Accepted Answer

Use BigDecimal with an appropriate scale and rounding mode.. Floating-point arithmetic inherently has rounding errors due to binary representation. BigDecimal provides arbitrary-precision decimal arithmetic and allows specifying rounding modes, making it ideal for exact calculations. Option B is the correct approach. Option A (using float) reduces precision and worsens errors. Option C (Math.round) rounds to integer, not applicable. Option D (casting to int) truncates and loses fractional part.

Answer

Apply Math.round() to the result to reduce decimal places.

Answer

Use the float data type instead of double to reduce memory usage.

Answer

Cast the result to int after multiplying by a power of 10.

Question 6

A large enterprise application is experiencing intermittent crashes on a production server running Java 8. The crash logs show 'java.lang.OutOfMemoryError: Metaspace'. The application heavily uses frameworks like Hibernate and JasperReports, which generate many classes dynamically at runtime. The server is configured with default JVM options except for -Xmx2g. A junior administrator suggests increasing -Xmx to 4g. What is the most effective solution to prevent these crashes?

Accepted Answer

Set -XX:MaxMetaspaceSize to a higher value. Option B is correct. Metaspace is used for class metadata; dynamic class generation fills metaspace. The default MaxMetaspaceSize is unlimited but can be constrained by available native memory. Increasing MaxMetaspaceSize (or leaving it unlimited) is the direct fix. Option A is incorrect because -Xmx increases heap, not metaspace. Option C is incorrect because UseCompressedOops optimizes heap memory, not metaspace. Option D is incorrect because switching GC may not address the metaspace exhaustion.

Answer

Enable -XX:+UseCompressedOops

Answer

Increase -Xmx to 4g

Answer

Switch to -XX:+UseParallelGC

Question 7

A junior developer writes a simple 'Hello World' program and saves it as HelloWorld.java. He compiles it successfully with 'javac HelloWorld.java', confirming that HelloWorld.class is created in the current directory. When he tries to run it with the command 'java HelloWorld', the system returns 'Error: Could not find or load main class HelloWorld'. The current directory is indeed the one containing HelloWorld.class. He has JAVA_HOME set to the JDK installation directory and has verified that java is in the PATH. What is the most likely cause?

Accepted Answer

The classpath does not include the current directory. Option C is correct. By default, the java command does not include the current directory in the classpath. The developer must explicitly add it using -cp . or set the CLASSPATH environment variable. Option A is incorrect because a corrupt class file would typically cause a different error (e.g., ClassFormatError). Option B is incorrect because a missing or incorrect main method would yield 'Main method not found' error. Option D is incorrect because the java command ran (the error message indicates java executed), so it must be in the PATH.

Answer

The class file is corrupt

Answer

The main method is missing or incorrectly declared

Answer

The java command is not in the PATH

Question 8

A company manages employee data stored in an array of Employee objects. The HR application frequently needs to find an employee by ID. The current implementation uses a linear search through the array each time. Performance reports indicate that this search is becoming a bottleneck as the company grows. The array is not sorted, and the company does not want to sort it because the order is meaningful for display. The array is large and frequently updated. The development team considers several options to improve the search performance without changing the array order. Which approach should they implement?

Accepted Answer

Create a HashMap<Integer, Employee> that maps IDs to Employee objects, and maintain it alongside the array.. Option B is the best because it provides O(1) lookup while preserving the original array order. Option A uses a HashSet of IDs but does not store Employee objects; you still need to retrieve the Employee. Option C requires sorting a copy each time, which is inefficient. Option D may improve but still O(n) and adds overhead of parallelization.

Answer

Use parallel streams to perform the search in parallel.

Answer

Convert the array to a HashSet of employee IDs and use contains() to check existence.

Answer

Use Arrays.binarySearch() on the array after temporarily sorting a copy each time.

Question 9

You are responsible for deploying a Java desktop application that uses JavaFX and various third-party libraries. The application is modular and uses JPMS. To reduce the footprint and startup time, you decide to use jlink to create a custom runtime image that includes only the required modules. The application has a main module `com.myapp` that requires `javafx.controls`, `javafx.base`, and some other modules. After creating the runtime image using the command `jlink --module-path $JAVA_HOME/jmods:lib --add-modules com.myapp --output myapp-image`, you test the image on a development machine, and it works. However, when deploying to a customer's machine, the application fails to start with an error: "Error: Could not find or load main class com.myapp.Main". The customer's machine has no Java installed. The runtime image includes the `com.myapp` module. You verify that the `myapp-image/bin/java` launcher exists. The main class is correctly declared in the module-info.java of `com.myapp`. What is the most likely cause of this error?

Accepted Answer

Use the `--launcher` option in jlink to create a launcher script that automatically runs the main class with the correct module.. Option B is correct because the `jlink` tool does not automatically create a launcher script that specifies the main class for the runtime image. Without the `--launcher` option, the generated `java` launcher does not know which module and main class to execute, leading to the 'Could not find or load main class' error when no Java is installed on the customer's machine. Using `--launcher` creates a custom script (e.g., `myapp`) that invokes `java --module com.myapp/com.myapp.Main`, ensuring the correct entry point is used.

Answer

Use the `--add-modules` option to include `javafx.controls` and other required modules in the command.

Answer

Add the `--bind-services` option to jlink to automatically include service provider modules.

Answer

Ensure that the `com.myapp` module reads all required modules by adding `requires` directives in module-info.java.

Question 10

You are maintaining a multi-threaded banking application that processes transactions. In the `processTransaction` method, you have a try-catch block that catches `Exception` to handle any unexpected errors. Recently, the application intermittently fails to update account balances correctly due to unhandled exceptions. The logs show that sometimes a `RuntimeException` is thrown from a nested method, but it is not being logged or handled properly, leading to inconsistent state. The team wants to improve the exception handling to ensure that all exceptions are caught, logged, and the transaction is rolled back properly. The method currently uses a primitive try-catch-finally where the finally block commits the transaction if no exception occurred. Which approach best addresses the issue while maintaining clarity and correctness?

Accepted Answer

Inside the try block, set a boolean success flag to true upon completion; in the finally block, check the flag: if false, rollback; if true, commit. Additionally, catch specific exceptions, log them, and ensure rollback logic is invoked.. Option C is correct: Use a try-catch block specifically for `RuntimeException` (and possibly other checked exceptions) to catch them, log, and roll back, then either rethrow or handle appropriately. The current catch of `Exception` is too broad and may be masking the fact that `RuntimeException` is not being logged because the catch block might not be executed if the exception occurs after the try block's scope? Actually, the issue is that the catch block may be catching but not properly rolling back. But more importantly, the method should not commit if any exception occurs; the finally block should only commit on success. Option A is wrong because adding a separate `RuntimeException` catch before the generic `Exception` catch is syntactically possible but still commits in finally unless rollback is called. Option B is wrong because using a finally block to commit always commits even if an exception occurred, unless you use a flag. Option D is wrong because using `throws` is not a handling strategy; it pushes the problem to the caller without resolving the rollback requirement.

Answer

Remove the `catch (Exception e)` block and rely solely on the finally block to commit or roll back based on a boolean flag set in the try block.

Answer

Add a separate catch block for `RuntimeException` before the existing `catch (Exception e)` and call rollback there, then rethrow the exception.

Answer

Declare the method with `throws Exception` and let the caller handle the transaction rollback.

Question 11

A team is developing a library management system. They have a base class 'Item' with a method 'getTitle()' that returns the title. They also have a subclass 'Book' that overrides 'getTitle()'. In some places, they have a method that accepts an Item reference but actually receives a Book object. They want to call a method specific to Book, such as 'getISBN()', that is not in Item. They attempt to cast the parameter: ((Book) item).getISBN(). However, occasionally the program crashes with ClassCastException. What is the best practice to avoid this exception?

Accepted Answer

Use if (item instanceof Book) before casting.. Option A is correct because using `instanceof` before casting ensures the object is actually an instance of `Book`, preventing a `ClassCastException` at runtime. This is the standard Java practice for safe downcasting when the object type is not guaranteed.

Answer

Create a separate method for Book objects.

Answer

Catch ClassCastException and handle it.

Answer

Change the parameter type to Object and then cast to Book.

Question 12

A mobile app backend uses Java streams to process user data. The code snippet filters users who are active and older than 18, then collects them into a list:

List<User> result = users.stream()
        .filter(u -> u.isActive())
        .filter(u -> u.getAge() > 18)
        .collect(Collectors.toList());

Performance metrics show that this stream operation is slow when the user list has millions of entries. The team wants to improve performance without changing the business logic. Which change would most likely improve performance?

Accepted Answer

Replace .stream() with .parallelStream().. Option A is correct because replacing `.stream()` with `.parallelStream()` enables parallel processing of the stream, which can leverage multiple CPU cores to process the filter operations concurrently. For large datasets (millions of entries), this can significantly reduce execution time by splitting the workload across threads, while preserving the same business logic and order of operations.

Answer

Use a HashSet instead of List for users collection.

Answer

Replace the stream with a traditional for loop.

Answer

Combine both filters into one using logical AND operator.

Question 13

A developer is writing a program to find the maximum value in an array of integers. The code is:

int[] nums = {10, 20, 5, 30, 15};
int max = 0;
for (int i = 0; i < nums.length; i++) {
    if (nums[i] > max) {
        max = nums[i];
    }
}
System.out.println(max);

The output is 30, which is correct for this array. However, the developer is concerned that if all numbers are negative, the output would be 0 instead of the highest negative number. Which modification ensures the algorithm works correctly for all integer arrays?

Accepted Answer

Initialize max to nums[0] and start loop from index 1.. The issue is that initializing max to 0 fails when all numbers are negative. The best practice is to initialize max to the first element of the array, or to Integer.MIN_VALUE. Option D (initialize to nums[0]) is correct. Option A (initialize to Integer.MIN_VALUE) also works, but option D is simpler. Option B (use a boolean flag) is overcomplicated. Option C (check if max is 0) is flawed.

Answer

Initialize max to Integer.MIN_VALUE.

Answer

Before assigning, check if max equals 0; if so, assign regardless.

Answer

Add a boolean flag to track if any element has been processed.

Question 14

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?

Accepted Answer

Move the inner loop's condition calculation outside the outer loop. Option B is correct because precomputing the loop limit (e.g., storing the result of the method call in a variable before the inner loop) reduces redundant method calls. Option A is wrong because changing to a while loop doesn't address the condition recalculation. Option C is wrong because break does not reduce the number of condition evaluations. Option D is wrong because recursion often adds overhead and is not suitable for this scenario.

Answer

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

Answer

Convert the loops to recursive calls

Answer

Change the inner loop to use a while loop

Question 15

You are developing a high-frequency trading application where performance is critical. You need to parse and concatenate trade messages. The messages are received as strings and must be combined into a single output string for logging. Each message is appended to the log string. Currently, you are using String concatenation with the '+' operator inside a loop that processes up to 10,000 messages per second. However, performance monitoring shows that the application experiences frequent garbage collection pauses, affecting throughput. Which approach should you take to reduce garbage collection overhead and improve performance?

Accepted Answer

Use StringBuilder instead of String concatenation, ensuring that the StringBuilder is created with an appropriate initial capacity.. StringBuilder is designed for efficient string concatenation without synchronization overhead. Creating it with an appropriate initial capacity further reduces reallocations. StringBuffer is thread-safe but adds unnecessary overhead in a single-threaded context. String.concat() still creates new objects. Increasing heap size only delays GC, not reduce object creation.

Answer

Use the String.concat() method for each concatenation to reduce object creation.

Answer

Use StringBuffer instead of String concatenation because it is thread-safe and efficient.

Answer

Keep using the '+' operator but increase the heap size to reduce garbage collection frequency.