1Z0-811 Practice Test 23 — 15 Questions

Question 1

What is printed by the program?

```java
for (int i = 0; i < 2; i++) {
    for (int j = 0; j < 3; j++) {
        System.out.print(i + "," + j + " ");
        if (i == 1) break;
    }
}
```

Accepted Answer

0,0 0,1 0,2 1,0. The program uses nested for loops. The outer loop runs with i from 0 to 1 (inclusive). For each i, the inner loop runs with j from 0 to 2 (inclusive). However, the inner loop contains a break statement that executes when i equals 1, causing the inner loop to terminate after printing the first pair for i=1 (1,0). Thus, the output is: 0,0 0,1 0,2 1,0. The outer loop then increments i to 2, but the condition i < 2 fails, so the program ends.

Answer

0,0 0,1 0,2

Answer

0,0 0,1 0,2 1,0 1,1 1,2 2,0 2,1 2,2

Answer

0,0 0,1 0,2 1,0 1,1

Question 2

Given the array declaration: int[] data = new int[5];, what is the value of data[2] after initialization?

Accepted Answer

0. In Java, when an array of primitive type `int` is created using `new int[5]`, all elements are automatically initialized to the default value for `int`, which is `0`. Therefore, `data[2]` (the third element) holds the value `0` after initialization.

Answer

2

Answer

false

Answer

null

Question 3

Which of the following is NOT a primitive data type?

Accepted Answer

String. String is a class in Java, not a primitive data type. The eight primitive types are byte, short, int, long, float, double, boolean, and char. String is a reference type that stores a sequence of characters as an object.

Answer

int

Answer

boolean

Answer

char

Question 4

Given the code:

public class Test {
    public static void change(int[] arr) {
        arr = new int[]{10, 20};
    }
    public static void main(String[] args) {
        int[] arr = {1, 2};
        change(arr);
        System.out.println(arr[0]);
    }
}

What is the output?

Accepted Answer

1. In Java, array references are passed by value. Inside the `change` method, the local variable `arr` is reassigned to a new array, but this does not affect the original array reference in `main`. Therefore, `arr[0]` in `main` still refers to the original array element `1`.

Answer

10

Answer

20

Answer

Compilation error

Question 5

Given method: static void change(String s) { s = "new"; } What is output of: String name = "original"; change(name); System.out.println(name);

Accepted Answer

"original". Java passes object references by value. Inside the method `change`, the local variable `s` is reassigned to a new String object, but this does not affect the original reference `name` in the main method. Strings are immutable, so the original `name` remains "original".

Answer

null

Answer

"new"

Answer

Compilation error

Question 6

Given the method: 'public static void swapFirstTwo(int[] arr) { int temp = arr[0]; arr[0] = arr[1]; arr[1] = temp; }'. What is the effect of calling this method with an array of length 1?

Accepted Answer

An ArrayIndexOutOfBoundsException is thrown.. The method accesses arr[0] and arr[1] without verifying the array length. When called with an array of length 1, index 1 is out of bounds because valid indices are 0 only. Java performs runtime bounds checking, so an ArrayIndexOutOfBoundsException is thrown.

Answer

The first element is swapped with itself.

Answer

A new array with length 2 is returned.

Answer

The array remains unchanged.

Question 7

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. The crash is caused by Metaspace exhaustion due to dynamic class generation by frameworks like Hibernate and JasperReports. The default MaxMetaspaceSize is unlimited, but the JVM may still hit native memory limits. Setting -XX:MaxMetaspaceSize to a higher value (or leaving it unlimited but with more available memory) directly addresses the issue. Option B (Increasing -Xmx) only increases heap size, which does not affect Metaspace. Option A (UseCompressedOops) optimizes object references in the heap, not class metadata. Option C (UseParallelGC) changes the garbage collector but does not prevent Metaspace growth. Therefore, Option D is the most effective solution.

Answer

Enable -XX:+UseCompressedOops

Answer

Increase -Xmx to 4g

Answer

Switch to -XX:+UseParallelGC

Question 8

Which TWO statements about the finally block are true? (Choose two.)

Accepted Answer

A try block must be followed by either a catch or finally.. A try block must be followed by at least one catch block or a finally block in Java. Option C is correct because the finally block is intended for resource cleanup code that always executes, regardless of whether an exception occurs. Options B, D, and E are false: B because finally always executes unless the JVM exits; D because finally can contain a return statement (though not recommended); E because finally executes after the catch block only when a catch block is invoked—if no exception occurs, there is no catch block, so the statement is not universally true.

Answer

The finally block executes only if an exception is thrown.

Answer

The finally block cannot contain a return statement.

Answer

The finally block is executed after the catch block.

Question 9

A team is using a build tool to compile and package a Java application. They want to automatically run unit tests after compilation and before packaging. Which tool and configuration is most appropriate?

Accepted Answer

Maven with lifecycle phases: test after compile.. Maven's lifecycle phases are ordered: compile, test, package. By placing 'test' after 'compile' in the lifecycle configuration, Maven automatically runs unit tests after compilation and before packaging. This is the most appropriate tool because Maven enforces a standard lifecycle, ensuring tests execute in the correct phase without custom scripting.

Answer

Jenkins pipeline with a stage for compile and test.

Answer

Ant with a target that depends on compile.

Answer

Gradle with a task that runs test after assemble.

Question 10

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 and throws an ArithmeticException if the result overflows, exactly meeting the requirement to detect overflow and throw an exception without changing data types. Option A (bitwise AND) does not detect overflow reliably. Option C (casting to long) changes the data type, violating the legacy constraint. Option D (BigInteger) also changes the data type. Therefore, option B is correct.

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 11

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 (double) inherently has rounding errors due to binary representation, as shown in the example 0.1 + 0.2 = 0.30000000000000004. BigDecimal provides arbitrary-precision decimal arithmetic and allows specifying scale and rounding modes, making it ideal for exact decimal calculations meeting the 10-digit precision requirement. Therefore, Option A (BigDecimal) is the correct approach. Option B (Math.round) rounds to an integer, losing fractional precision. Option C (float) uses less precision than double, worsening errors. Option D (casting to int after scaling) truncates and risks loss of information.

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 12

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

Accepted Answer

do-while loop. The do-while loop is a post-test loop, meaning the condition is evaluated after the loop body executes. This guarantees that the body runs at least once, regardless of whether the condition is initially true or false. In Java, the do-while loop syntax is `do { ... } while (condition);`.

Answer

repeat-until loop

Answer

while loop

Answer

for loop

Question 13

You are a Java developer at a financial firm. The application processes transactions from a queue. The team recently migrated from Java 8 to Java 11. After the migration, the application intermittently throws an exception: 'java.lang.reflect.InaccessibleObjectException: Unable to make field private final byte[] java.lang.String.value accessible: module java.base does not 'opens java.lang' to unnamed module'. This error occurs when the application tries to use reflection to access private fields of String objects for serialization. The application runs on a server where you cannot modify the JVM startup scripts. However, you can modify the application code and the module-info.java file. You need to resolve the exception without breaking existing functionality. Which approach should you take?

Accepted Answer

Refactor the code to use public APIs instead of reflecting on String's internal fields.. The root cause is that the application uses reflection to access private fields of java.lang.String, which is prohibited in Java 9+ by default due to module system encapsulation. Refactoring to use public APIs (e.g., String.getBytes(), String.charAt()) eliminates the need for reflection entirely, resolving the InaccessibleObjectException without requiring JVM flags or module declarations, and preserves compatibility with Java 11.

Answer

Add --add-opens java.base/java.lang=ALL-UNNAMED to the JVM command line.

Answer

Use sun.misc.Unsafe to access the String field directly.

Answer

Add 'opens java.lang;' to the module-info.java file.

Question 14

What is the result of the expression 10 % 3?

Accepted Answer

1. The modulo operator (%) in Java returns the remainder of the division of the left operand by the right operand. Since 10 divided by 3 equals 3 with a remainder of 1, the expression 10 % 3 evaluates to 1.

Answer

3.33

Answer

0

Answer

3

Question 15

A company's HR system uses an Employee class with sensitive salary information. The team wants to allow other classes to read the salary but not modify it. Which approach best preserves encapsulation?

Accepted Answer

Provide a public getSalary() getter method and keep salary private. Encapsulation is achieved by keeping fields private and providing public getters. A getter allows read-only access without exposing the internal representation.

Answer

Declare the salary field as public

Answer

Create a private method that returns salary only when called from within the same package

Answer

Provide a public setSalary() setter method and keep salary private