1Z0-811 Practice Test 37 — 15 Questions

Question 1

A developer is tasked with deploying a Java application to a customer's server. The customer has only a JRE installed and no internet access. The application uses Java NIO and requires reading configuration files from the classpath. The application compiles and runs fine on the developer's machine which has JDK 11. However, when deploying the compiled JAR to the customer's JRE 11, it throws a 'NoClassDefFoundError' for a class that is part of the JDK's internal API (e.g., com.sun.nio.file.SensitivityWatchEventModifier). The developer is confused because the class is in the standard library. Which action should be taken to resolve the issue?

Accepted Answer

Modify the code to use a public API from the standard library. Option A is correct. The issue is that the code uses an internal API that is encapsulated in Java 11. The correct solution is to replace it with a public API (e.g., using java.nio.file.StandardWatchEventKinds). Option B is incorrect because installing the JDK would expose the internal classes but is not a proper solution and may violate encapsulation. Option C is incorrect because the missing class is not a separate JAR; it's part of the JDK internal API. Option D is incorrect because recompiling with a lower target version does not change the use of internal APIs and may introduce other issues.

Answer

Recompile with a lower target version

Answer

Add the missing JAR file to the classpath

Answer

Install the JDK on the customer's server

Question 2

A developer is maintaining a Java backend service for order processing. The service uses a third-party library that throws a checked PaymentException when a payment fails. The current processOrder method catches Exception generically, logs the error, and returns null. The business requires that when a payment fails, the order status must be updated to 'FAILED' in the database, and a notification must be sent to the customer. However, due to the generic catch, these actions are not performed. The developer must modify the code to meet the business requirements without changing the external API of the class (i.e., the method signature must remain the same and must not throw any exceptions to the caller). Which course of action should the developer take?

Accepted Answer

In the catch block, check if the exception is an instance of PaymentException, then update the order status and send notification. Do not rethrow the exception.. The best course is to catch PaymentException specifically, perform the required business logic (update order status and send notification), and then either not rethrow the exception or rethrow it as an unchecked exception if needed. However, the requirement says 'must not throw any exceptions to the caller', so the method should not propagate any exception. Option A catches PaymentException, handles the business logic, and then rethrows a RuntimeException, which would propagate to the caller, violating the requirement. Option B removes exception handling, causing checked Exception to be thrown, which also propagates. Option D uses a finally block, which would execute even on success, leading to incorrect notifications. Option C catches Exception, checks if it is PaymentException, handles the business logic, and then does not rethrow the exception, ensuring the method completes normally. This satisfies the requirement while handling the specific exception.

Answer

Catch PaymentException specifically, update the order status and send notification, then throw a new RuntimeException to indicate failure.

Answer

Remove the try-catch block and declare the method with throws Exception, allowing the caller to handle payment failures.

Answer

Use a finally block to update the order status and send notification regardless of success or failure.

Question 3

A developer is building a Java application for a bank that processes account transactions. The application reads transaction amounts from a CSV file provided by a third party. The amounts are in string format, e.g., '1,234.56' or '$5,000.00'. The developer uses Integer.parseInt() to convert these strings to integers for processing. However, many transactions fail with NumberFormatException. The developer adds a try-catch block to catch the exception and log the error. But still, the application fails to process valid transactions because the parsing does not handle the formatting. The development team is considering several approaches to fix this issue. The goal is to parse the string into an integer representing the whole dollar amount (ignoring cents and formatting). Which course of action should the developer take?

Accepted Answer

Use String.replaceAll("[^0-9]", "") to remove non-digit characters before parsing.. The best approach is to remove all non-digit characters before parsing. Using String.replaceAll("[^0-9]", "") strips commas, currency symbols, and decimal points, leaving only digits, which Integer.parseInt can handle. Option B is correct. Option A (Scanner) is cumbersome for a single string. Option C (BigDecimal) is overkill and still requires cleanup, plus intValue() loses precision. Option D is impractical for formatting issues.

Answer

Use BigDecimal to represent the value and then convert to int using intValue().

Answer

Use a custom parser that throws a checked exception to enforce proper formatting.

Answer

Use a Scanner with useDelimiter("[^0-9]") to extract digits.

Question 4

A developer is writing a batch processing application that reads a list of orders and processes each one. The orders are stored in an array of Order objects. The processing logic is complex and involves multiple conditional checks. The developer uses a for-each loop to iterate over the array. However, during testing, the application throws an IndexOutOfBoundsException when processing orders that have a status of "CANCELLED". The developer wants to skip the processing of cancelled orders but still record that the order was skipped in a log. The current code is:

for (Order order : orders) {
    if (order.getStatus().equals("CANCELLED")) {
        // Skip
    }
    // process order
    process(order);
    log(order);
}

The developer considers four options:

A. Change the for-each loop to a traditional for loop with an index and increment only when order is not cancelled.
B. Add a continue statement inside the if block.
C. Change the if condition to check for non-cancelled orders and wrap only the process(order) call inside the if block, leaving log(order) outside.
D. Use a while loop with an iterator and remove cancelled orders from the array.

Which option best solves the problem without modifying the array and while still logging all orders?

Accepted Answer

Change the if condition to check for non-cancelled orders and wrap only the process(order) call inside the if block, leaving log(order) outside.. Option C correctly skips only the processing for cancelled orders while still executing the log statement for them. Option A would require index management and still log for cancelled orders, but it changes the loop structure unnecessarily. Option B would skip both process and log for cancelled orders, failing the logging requirement. Option D modifies the array by removing elements, which is not allowed ('without modifying the array'). Thus C is the best.

Answer

Change the for-each loop to a traditional for loop with an index and increment only when order is not cancelled.

Answer

Add a continue statement inside the if block.

Answer

Use a while loop with an iterator and remove cancelled orders from the array.

Question 5

A company develops a payroll system in Java with a hierarchy: Employee, Manager (extends Employee), and Director (extends Manager). Each class overrides a method getDetails() that returns a string with employee information. Employee's getDetails() returns name and ID. Manager's getDetails() adds department. Director's getDetails() adds division. The system uses a single method printDetails(Employee e) that calls e.getDetails(). After a recent deployment, the system prints only the name and ID for all employees, even for managers and directors. The code review reveals that Employee's getDetails() is declared with default (package-private) access, while the overridden versions in Manager and Director are public. The printDetails method and the Manager/Director classes are in different packages. What is the most likely cause and the correct solution?

Accepted Answer

Change the access modifier of getDetails() in Employee to public (or protected).. Option A is correct. In Java, a default-access method is not visible to subclasses in different packages, so Manager and Director cannot override it; their getDetails() methods are new methods, not overriding Employee's. Making Employee's getDetails() public (or protected) allows proper overriding and polymorphic behavior. Option B is wrong because it bypasses polymorphism. Option C is wrong because @Override only helps catch errors, but the access issue remains. Option D is wrong because making the method final would prevent overriding entirely.

Answer

Modify printDetails() to accept Manager or Director objects instead of Employee.

Answer

Add @Override annotation to the overridden methods in Manager and Director.

Answer

Declare getDetails() in Employee as final to ensure consistent behavior.

Question 6

A social media platform processes user login requests. Each request generates a welcome message by concatenating the username with a fixed greeting using the + operator inside a loop that runs hundreds of times per second for thousands of users. The development team notices that the application suffers from high memory consumption and slow response times under load. They profile the code and discover that the method building the welcome message is a bottleneck. The team considers several options to improve performance while maintaining thread safety. Which approach should the team implement?

Accepted Answer

Replace string concatenation with StringBuilder and allocate an initial capacity large enough to hold the final message.. Option B is correct: StringBuilder with sufficient initial capacity reduces memory reallocations and is faster than StringBuffer for single-threaded contexts. Option A (StringBuffer) is thread-safe but slower due to synchronization, not needed here since the method is not shared across threads. Option C (concat()) still creates new strings internally, similar to + operator. Option D (intern()) does not improve performance and may cause memory issues.

Answer

Replace string concatenation with StringBuffer and use an initial capacity to minimize resizing.

Answer

Keep using the + operator but call intern() on the resulting string to reuse memory.

Answer

Replace string concatenation with the concat() method called on the greeting string.

Question 7

A development team is building a modular Java application using Java 17. They have defined a module named com.myapp with a module-info.java that includes 'requires com.thirdparty.lib;'. The com.thirdparty.lib module is a third-party library packaged as a modular JAR with its own module-info.class. The application compiles successfully using javac with the module path pointing to the directory containing the JAR. However, when starting the application with java --module-path <path> --module com.myapp, a NoClassDefFoundError occurs for a class from com.thirdparty.lib. The error message indicates the class is not found. The team has confirmed that the JAR file is present in the specified module path and that the class exists in the JAR. No other errors or warnings are displayed. The team is puzzled because the code compiles without issues. What is the most likely cause of this runtime error?

Accepted Answer

The module com.thirdparty.lib does not export the package containing the required class in its module-info.java.. In modular Java, a module must export a package for its classes to be accessible by other modules. If com.thirdparty.lib does not export the package containing the required class, that class will not be found at runtime, even though the module is present. This is a common issue when migrating from classpath-based to module-path-based applications. Option A is correct because the module's exports directive is missing. Option B is incorrect because module path order does not affect accessibility of exported packages; it affects module resolution, but the module is resolved. Option C is incorrect because version conflicts typically cause different errors (e.g., NoSuchMethodError). Option D is incorrect because if the library were incompatible, compilation would likely fail or errors would be different.

Answer

The module path order is incorrect, causing a different version of the library to be loaded.

Answer

The library is not compatible with Java 17.

Answer

The application's module requires the wrong version of the library.

Question 8

A developer is writing a method to compute the average of an array of scores. The method should handle edge cases gracefully. The scores array may be empty or contain null values if the collection was interrupted. The scores are stored as primitive doubles. Which implementation is safest and follows best practices?

Accepted Answer

public double average(double[] scores) { if (scores == null) return 0.0; double sum = 0; for (double s : scores) sum += s; return scores.length == 0 ? 0.0 : sum / scores.length; }. Option D is correct because it explicitly checks for both a null array and an empty array before performing the division. The null check prevents a NullPointerException, and the ternary operator `scores.length == 0 ? 0.0 : sum / scores.length` avoids division by zero when the array is empty. This follows best practices by handling edge cases without relying on exceptions for flow control.

Answer

public double average(double[] scores) { if (scores == null || scores.length == 0) return 0.0; double sum = 0; for (double s : scores) sum += s; return sum / scores.length; }

Answer

public double average(double[] scores) { double sum = 0; for (double s : scores) sum += s; return sum / scores.length; }

Answer

public double average(double[] scores) { try { double sum = 0; for (double s : scores) sum += s; return sum / scores.length; } catch (NullPointerException | ArithmeticException e) { return 0.0; } }

Question 9

A new developer writes a method that accepts an array and intends to swap the first and last elements. The code is: public static void swapEnds(int[] arr) { int temp = arr[0]; arr[0] = arr[arr.length-1]; arr[arr.length-1] = temp; } What is a potential issue with this method if the array is empty?

Accepted Answer

It will throw an ArrayIndexOutOfBoundsException.. When the array is empty, `arr.length` is 0, so `arr.length - 1` evaluates to -1. Accessing `arr[-1]` throws an `ArrayIndexOutOfBoundsException` because array indices must be non-negative and less than the array length. The method does not check for an empty array before attempting the swap.

Answer

It will throw a NullPointerException.

Answer

It will produce incorrect result because arr.length-1 is negative.

Answer

It will compile and run correctly.

Question 10

You are a Java developer working on an enterprise application that uses a modular architecture with Java Platform Module System (JPMS). The application consists of several modules: `com.app.core`, `com.app.util`, `com.app.service`, and `com.app.client`. The application runs on a server that has Java 17 installed. Recently, the operations team reported that after a deployment, the application fails to start with a `NoClassDefFoundError` for a class in `com.app.util`, even though the class exists in the compiled module. The deployment process uses a custom script that compiles the modules using `javac` with `--module-source-path`, then uses `jlink` to create a custom runtime image that includes only the required modules. The runtime image is then deployed to the server. The build logs show no errors during compilation or linking. However, on the server, the error occurs. The server has multiple versions of the same library on the classpath due to legacy scripts. You suspect that the error is due to a module resolution issue. Which corrective action should you take?

Accepted Answer

Remove any classpath entries from the server startup script and rely exclusively on the module path provided by the runtime image.. Option B is correct because the `NoClassDefFoundError` occurs when the custom runtime image built with `jlink` is deployed, but legacy scripts add classpath entries that cause module resolution conflicts. JPMS requires that all dependencies be on the module path; mixing classpath entries can lead to split packages or incorrect module resolution, resulting in the error. Removing classpath entries ensures the runtime image's module path is used exclusively, resolving the issue.

Answer

Recompile the application without using modules by placing all classes on the classpath instead.

Answer

Ensure that the module `com.app.util` exports the package containing the missing class in its module-info.java.

Answer

Add detailed logging in the module's initialization to trace the class loading and identify where the error originates.

Question 11

You are tasked with debugging a Java application that processes temperature sensor readings. The application reads an array of double values representing temperatures in Celsius, and should output the number of readings that exceed a threshold of 30.0°C. The current implementation is:

public class TemperatureAnalyzer {
    public static void main(String[] args) {
        double[] readings = {25.5, 32.1, 30.0, 28.9, 35.7};
        int count = 0;
        for (int i = 0; i < readings.length; i++) {
            if (readings[i] > 30.0) {
                count++;
            }
        }
        System.out.println("Count: " + count);
    }
}

However, the output is "Count: 3" instead of the expected 2 (since 30.0 is not above the threshold). The developer believes the issue is that the condition should be '>=' to include 30.0, but the specification says strictly above 30.0. After further investigation, you discover that the problem is due to floating-point imprecision when comparing with the literal 30.0. Which of the following changes would correctly fix the comparison to reliably count readings strictly greater than 30.0, considering floating-point representation?

Accepted Answer

Change the condition to (readings[i] - 30.0) > Double.MIN_VALUE.. Option B is correct because comparing the difference `(readings[i] - 30.0) > Double.MIN_VALUE` correctly identifies values strictly greater than 30.0 while accounting for floating-point imprecision. `Double.MIN_VALUE` is the smallest positive nonzero double (≈ 4.9e-324), so any positive difference larger than that indicates the reading is truly above 30.0, avoiding false positives from tiny rounding errors.

Answer

Change the data type of readings to int and multiply all values by 10 to preserve one decimal place, then compare with 300.

Answer

Change the condition to Math.abs(readings[i] - 30.0) > 0.0.

Answer

Change the threshold literal to 30.0f (float) and compare using Float.compare(readings[i], threshold) > 0.

Question 12

A financial trading application processes high-volume transactions. The system uses a multithreaded architecture where multiple threads update a shared Account object's balance field. Recently, intermittently incorrect balance calculations have been reported. Developers suspect a race condition on the balance field. The Account class is defined as follows:

public class Account {
    private double balance = 0.0;
    public void deposit(double amount) { balance += amount; }
    public void withdraw(double amount) { balance -= amount; }
    public double getBalance() { return balance; }
}

Threads are created using ExecutorService with a fixed thread pool. The issue occurs only under heavy load. Which course of action should the development team take to resolve the issue while maintaining performance?

Accepted Answer

Synchronize the deposit and withdraw methods.. Option D is correct because synchronizing the `deposit` and `withdraw` methods ensures mutual exclusion on the `balance` field. In Java, the compound operations `balance += amount` and `balance -= amount` are not atomic; they involve a read, modify, and write sequence. Synchronization guarantees that only one thread executes these methods at a time, preventing race conditions and ensuring correct balance calculations under heavy load.

Answer

Declare the balance field as volatile.

Answer

Use AtomicLong and convert to double.

Answer

Wrap the balance field in a synchronized block within each method using a separate lock object.

Question 13

A developer is writing a method to find the first occurrence of a negative number in an array and return its index, or -1 if none found. The current implementation uses a for loop with an if condition and a return when found. However, the method throws a NullPointerException when the array is null. The developer wants to handle this edge case gracefully and still return -1. Which approach is most appropriate?

Accepted Answer

Add a null check at the beginning of the method and return -1 if null. Option A is correct because it directly checks if the array reference is null before any iteration, returning -1 immediately. This is the simplest and most efficient way to handle a null input, avoiding any attempt to access the array's length or elements, which would throw a NullPointerException. The method's contract is preserved by returning -1 when no negative number is found, including the case of a null array.

Answer

Use an enhanced for loop with a null check

Answer

Use a try-catch block inside the loop

Answer

Use a while loop with a null check inside

Question 14

A company is developing a Java-based inventory management system. The system runs on a single server and processes up to 1000 concurrent requests. The development team has implemented the code using multiple threads to handle requests. Recently, the system has been experiencing intermittent data corruption in the inventory counts. After reviewing the code, the team suspects that the issue is related to thread safety. The team is considering the following solutions: (A) Use the 'synchronized' keyword on all methods that update inventory counts. (B) Use 'volatile' keyword on the inventory count variables. (C) Use 'AtomicInteger' for inventory counts. (D) Increase the number of threads to handle requests faster. Which solution should the team implement to fix the data corruption issue with minimal performance impact?

Accepted Answer

Use 'AtomicInteger' for inventory counts.. Option A is correct because AtomicInteger provides thread-safe atomic operations (like incrementAndGet) without requiring synchronization, ensuring consistent inventory counts under concurrent access with minimal performance overhead compared to full method synchronization.

Answer

Increase the number of threads to handle requests faster.

Answer

Use 'volatile' keyword on the inventory count variables.

Answer

Use the 'synchronized' keyword on all methods that update inventory counts.

Question 15

You are writing a program that processes a list of transactions. Each transaction has a timestamp (long), amount (double), and type (String). The program needs to iterate through the transactions in the order they were added. Which collection should you use to maintain insertion order and allow fast iteration?

Accepted Answer

ArrayList<Transaction>. ArrayList maintains insertion order and provides O(1) random access and fast iteration via index-based traversal. It is the correct choice when you need to preserve the order in which elements were added and iterate over them sequentially without requiring sorting or unique constraints.

Answer

TreeSet<Transaction>

Answer

LinkedList<Transaction>

Answer

HashSet<Transaction>