1Z0-811 Arrays and Methods Practice Test 6 — 15 Questions

Question 1

What is the result of the following code? int[] arr = new int[3]; arr[3] = 5; System.out.println(arr[3]);

Accepted Answer

Runtime exception. The code attempts to access index 3 of an array of length 3. Since Java arrays are zero-indexed, valid indices are 0, 1, and 2. Accessing index 3 throws an ArrayIndexOutOfBoundsException at runtime, so option A is correct.

Answer

0

Answer

5

Answer

Compilation error

Question 2

A developer wants to sort an array of primitive ints in descending order. Which approach will work without using third-party libraries?

Accepted Answer

Arrays.sort(arr); // then reverse the array manually. `Arrays.sort(int[])` sorts the array in ascending order, and then manually reversing the array yields descending order. The other options fail because `Arrays.parallelSort()` also sorts ascending, `Collections.reverseOrder()` requires an array of objects (not primitives), and a custom comparator cannot be used with primitive arrays in Java.

Answer

Arrays.parallelSort(arr);

Answer

Arrays.sort(arr, Collections.reverseOrder());

Answer

Arrays.sort(arr, (a,b) -> b - a);

Question 3

Which two statements about method parameter passing in Java are true? (Choose two.)

Accepted Answer

When a primitive type is passed to a method, a copy of the value is passed.. Option C is correct because Java is strictly pass-by-value, so when a primitive (e.g., int, double, boolean) is passed, the method receives an independent copy of the value, and any reassignment inside the method does not affect the caller's variable. Option D is correct because for objects, Java passes the reference by value: the method receives a copy of the reference, so it can mutate the referenced object's state (e.g., call setters or modify fields), but reassigning the parameter to a new object does not change the caller's reference. Option A is wrong because arrays are objects, so modifying array elements through the passed reference is visible to the caller. Option B is wrong because reassigning the parameter inside the method only changes the local copy of the reference, leaving the caller's array reference unchanged. Option E is wrong because String is immutable, so no method can modify the original String's contents; any apparent change creates a new String object.

Answer

When an array is passed to a method, changes to the array elements inside the method are not reflected in the caller.

Answer

When an array is reassigned inside a method, the original array in the caller is also reassigned.

Answer

When a String is passed to a method, the method can modify the original String.

Question 4

Which three statements about arrays are correct? (Choose three.)

Accepted Answer

Arrays are objects in Java.. Option B is correct because in Java an array is a dynamically created object that extends Object, so it can be assigned to an Object reference and has members such as the length field. Option D is correct because a single array type can hold either primitive values (e.g., int[], double[]) or reference values to objects (e.g., String[], Object[]), though a given array holds only one component type. Option E is correct because Java array indexing is zero-based, meaning the first element is at index 0 and the last valid index is length - 1. Option A is incorrect because once an array is created its length is fixed and cannot be changed, although a variable can be reassigned to a different array. Option C is incorrect because array length need not be a compile-time constant; it can be determined at runtime, as in new int[n] where n is a variable.

Answer

The size of an array can change after creation.

Answer

The length of an array must be specified at compile time with a constant expression.

Question 5

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 that maps IDs to Employee objects, and maintain it alongside the array.. The best choice because using a HashMap provides O(1) average-time lookups, which is far superior to linear search. The HashMap can be maintained alongside the array without disturbing the array order, as updates to the array are reflected in the HashMap. Option B (parallel streams) still performs a linear search (O(n)) and adds overhead for parallelization, so it does not solve the bottleneck. Option C (HashSet of IDs) only allows checking existence but does not provide the Employee object; you would still need to search the array to retrieve the Employee, so it does not reduce complexity. Option D (binary search on a sorted copy) requires O(n log n) time to sort a copy for each search, which is even worse than linear search.

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 6

A team is developing a financial application that processes large arrays of market data. They have a method that calculates moving averages by copying a subarray for each window. The current implementation creates a new array for each window using System.arraycopy. The application is running slowly in production. The team identifies that the method is called millions of times per minute. The array is large and the window size is small. The garbage collector overhead is high due to many short-lived arrays. Which optimization should they apply to reduce object creation and improve performance?

Accepted Answer

Use a single temporary array and reuse it by copying data into it for each window.. Reusing a single temporary array eliminates the repeated allocation of short-lived arrays for each window, directly reducing garbage collector overhead. The current implementation uses System.arraycopy to create a new array per window, which is the primary source of object churn. By allocating one array once and copying data into it for each window, the team minimizes object creation while still performing the necessary copy operation.

Answer

Use a Stream to process the array without creating intermediate arrays.

Answer

Use Arrays.copyOfRange() which is faster than System.arraycopy.

Answer

Use ArrayList instead of array to avoid copy.

Question 7

In a login system, the authentication method receives an array of user roles as a String[] and checks if a specific role is present. The array may be large (thousands of roles), and the method is called frequently for each user request. Performance is critical. The array is static and does not change after initialization. Which approach is most efficient for repeated checks?

Accepted Answer

Convert the array to a HashSet once and reuse it for lookups.. Converting the array to a HashSet once provides O(1) average-time complexity for subsequent contains() checks, which is far more efficient than O(n) linear search or O(log n) binary search when the method is called frequently on a static array. The HashSet leverages hash codes for direct bucket lookup, making it ideal for repeated membership tests on large, unchanging data sets.

Answer

Use a for loop to iterate and compare each string.

Answer

Sort the array and use Arrays.binarySearch().

Answer

Use a List and the contains() method.

Question 8

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 9

A developer is writing a method that should double every element in an int array passed as an argument. The method signature is public static void doubleAll(int[] nums). The developer wants the caller's original array to reflect the doubled values. Which implementation correctly achieves this?

Accepted Answer

for (int i = 0; i < nums.length; i++) { nums[i] *= 2; }. Arrays are objects, and Java passes object references by value. When a method receives an array reference, it can modify the array's elements, and those changes are visible to the caller. Reassigning the parameter to a new array does not affect the caller's reference. The correct implementation iterates from 0 to nums.length - 1 and updates each element in place using compound assignment.

Answer

nums = new int[nums.length]; for (int i = 0; i < nums.length; i++) { nums[i] *= 2; }

Answer

int[] doubled = new int[nums.length]; for (int i = 0; i < nums.length; i++) { doubled[i] = nums[i] * 2; } nums = doubled;

Answer

for (int i = 0; i <= nums.length; i++) { nums[i] *= 2; }

Question 10

A developer writes a utility method that accepts a variable number of int arguments and prints their sum. The method is declared as public static int sum(int... values). Which statement correctly describes how this method can be invoked?

Accepted Answer

It can be invoked with zero arguments, one int argument, or multiple int arguments.. A varargs parameter declared as int... values is compiled into an int[] parameter, and the compiler accepts zero or more int arguments at the call site, wrapping them into an array. This makes the method convenient for callers while keeping the implementation type-safe. The other invocation forms described are either overly restrictive or violate Java's type conversion rules.

Answer

It can be invoked with arguments of any numeric type, including double and long, because Java automatically widens them to int.

Answer

It must be invoked with at least one int argument; zero arguments causes a compile-time error.

Answer

It can be invoked only with an explicit int array, such as sum(new int[]{1,2,3}).

Question 11

A developer at a logistics company defines this method:

public static void addFee(double[] charges) {
    charges = new double[]{5.0, 10.0};
    charges[0] = 99.0;
}

It is invoked as:

double[] fees = {1.0, 2.0};
addFee(fees);
System.out.println(fees[0]);

What is printed?

Accepted Answer

1.0. Because Java is strictly pass-by-value, the method receives a copy of the reference. Reassigning that parameter to a new array disconnects it from the caller's object, so the later element write is invisible to the caller. Only mutating the aliased object itself, without reassigning the parameter, would change fees[0].

Answer

99.0

Answer

A NullPointerException is thrown.

Answer

5.0

Question 12

A developer is reviewing a method that searches a two-dimensional int array for a target value. The method must return true if the target appears anywhere in the array. Which two statements about passing and using a two-dimensional array as a method parameter are correct? (Choose two.)

Accepted Answer

The parameter can be declared as int[][] grid, and grid.length gives the number of rows.. A two-dimensional array parameter can be written as int[][] grid or equivalently as int grid[][]. The outer array's length gives the row count, and each row is itself an array whose length gives the column count. Arrays are objects passed by reference value, so no deep copy occurs, and varargs is unrelated to passing 2D arrays.

Answer

The method receives a deep copy of the array, so modifications to grid inside the method do not affect the caller's array.

Answer

The parameter must be declared as int... grid because two-dimensional arrays cannot be passed directly to methods.

Answer

Inside the method, grid.length returns the total number of elements across all rows.

Question 13

A developer writes the following code:

public class Test {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = a;
        b[0] = 99;
        System.out.println(a[0] + " " + b[0]);
    }
}

What is the output?

Accepted Answer

99 99. Array variables hold references to array objects. The statement int[] b = a copies the reference, not the array contents, so both variables point to the same object. Any modification through one reference is visible through the other. Thus, after b[0] = 99, both a[0] and b[0] evaluate to 99, and the program prints 99 99.

Answer

Compilation fails because you cannot assign an int array to another int array variable.

Answer

1 1

Answer

1 99

Question 14

A developer is reviewing code that iterates over a one-dimensional int array named readings using a standard for loop. The loop must access every element exactly once without any out-of-bounds errors. Which loop condition should be used?

Accepted Answer

i < readings.length. Because Java array indexes begin at zero, the highest valid index for any array is its length minus one. A loop that continues while the index is strictly less than the array length therefore touches every element exactly once and stops precisely before the first invalid index, making it the safe and conventional choice for full traversal.

Answer

i <= readings.length - 1

Answer

i <= readings.length

Answer

i < readings.length - 1

Question 15

A developer writes a method that is intended to double each element in an int array. The method is:

public static void doubleAll(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        nums[i] *= 2;
    }
}

What is the effect when the following code is executed?

int[] values = {1, 2, 3};
doubleAll(values);
System.out.println(values[1]);

Accepted Answer

The program prints 4, because the method modifies the shared array object.. When an array is passed to a method, the method receives a copy of the reference, so it can modify the elements of the caller's array. The indexed loop multiplies each element by 2, changing values[1] from 2 to 4. The method does not need to return the array because the modification is made directly to the shared object.

Answer

The program prints 2, because the enhanced for loop would be required to modify array elements.

Answer

The program prints 3, because the method does not return the modified array.

Answer

The program prints 2, because the method receives a copy of the array and changes do not affect the caller.