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

Question 1

Which THREE statements are true about passing arrays to methods in Java?

Accepted Answer

Varargs parameters allow passing zero or more arguments of the specified type.. Varargs (variable-length arguments) in Java allow a method to accept zero or more arguments of a specified type, using the syntax `Type... param`. This is syntactic sugar for an array parameter, and the method body treats it as an array. This enables flexible method invocation without requiring the caller to explicitly create an array.

Answer

If the method modifies elements of the array, the caller does not see the changes.

Answer

If the method assigns a new array to the parameter, the caller's variable is updated.

Question 2

Refer to the exhibit. What is the output?

Accepted Answer

2. The code initializes an array `arr` with values {1, 2, 3}. The for loop iterates over the array, and the `if` condition checks if the current element equals 2. When `arr[1]` (value 2) is encountered, the `break` statement exits the loop immediately. The loop executes only twice (for indices 0 and 1), so the counter `count` is incremented twice, resulting in output 2.

Answer

3

Answer

1

Answer

0

Question 3

Refer to the exhibit. Which overloaded methods cause this compilation error?

Accepted Answer

public void print(String[] s) and public void print(String... s). Java does not allow overloading methods that differ only by the use of a varargs parameter and an array parameter of the same type. Both `public void print(String[] s)` and `public void print(String... s)` have the same method signature after erasure — they both accept a `String[]` at the bytecode level — causing a compilation error due to ambiguity.

Answer

public void print(String s) and public void print(String[] s)

Answer

public void print(String s) and public void print(String... s)

Answer

public void print(Object... o) and public void print(String... s)

Question 4

Refer to the exhibit. The code at line 6 of ArrayExample.java is: int[] arr = {10, 20, 30, 40, 50}; int sum = 0; for (int i = 0; i <= arr.length; i++) sum += arr[i]; Which change fixes the exception?

Accepted Answer

Change loop condition to i < arr.length. The exception occurs because the loop condition `i <= arr.length` causes the loop to iterate one index beyond the array's last valid index (arr.length - 1). When `i` equals `arr.length` (5), `arr[5]` is accessed, which throws an ArrayIndexOutOfBoundsException. Changing the condition to `i < arr.length` ensures the loop runs only for indices 0 through 4, fixing the exception. Option D, changing `arr.length` to `arr.length - 1` in the condition, also technically fixes the exception, but it is not the standard or recommended fix; the intended correct answer is to use the `<` operator.

Answer

Change array declaration to int[] arr = new int[6];

Answer

Change loop initialization to i = 1

Question 5

Consider the following code that attempts to swap the first two elements of an array using a method:

public static void swap(int[] arr) {
    int temp = arr[0];
    arr[0] = arr[1];
    arr[1] = temp;
}

public static void main(String[] args) {
    int[] values = {1, 2};
    swap(values);
    System.out.println(values[0] + " " + values[1]);
}

What is the output?

Accepted Answer

2 1. The `swap` method receives a reference to the array, so modifications to its elements (via index assignment) affect the original array. After swapping, `values[0]` becomes 2 and `values[1]` becomes 1, producing the output "2 1".

Answer

The code does not compile.

Answer

1 2

Answer

A runtime exception occurs.

Question 6

A developer implements a method to check if a number exists in an array using binary search. The array is not sorted. What will happen?

Accepted Answer

The method returns incorrect results sometimes.. Binary search requires the array to be sorted to work correctly. If the array is not sorted, the algorithm may skip over the target element or incorrectly conclude it is absent, leading to incorrect results. Therefore, the method returns incorrect results sometimes.

Answer

The method returns correct results always.

Answer

Runtime exception.

Answer

Compilation error.

Question 7

Which approach does NOT create a new array that is independent of the original?

Accepted Answer

int[] copy = original;. Assigning one array variable to another does not create a new array; both variables reference the same array object.

Answer

int[] copy = Arrays.copyOf(original, original.length);

Answer

int[] copy = original.clone();

Answer

int[] copy = new int[original.length]; System.arraycopy(original, 0, copy, 0, original.length);

Question 8

A method is designed to reverse an array of integers. The method signature is: public static void reverse(int[] arr). The method correctly reverses the array. Which statement is true about the method?

Accepted Answer

It modifies the original array.. The method receives a reference to the array (pass-by-value of the reference), so any modifications made to the array elements inside the method directly affect the original array object in the caller's scope. Since the method reverses the array in-place by swapping elements, the original array is mutated.

Answer

It returns a new array that is the reverse of the input.

Answer

It cannot be called with a null array.

Answer

It uses pass-by-value, so the original array is unchanged.

Question 9

A developer writes a method that takes a variable number of integer arguments and returns the maximum. Which method signature is correct?

Accepted Answer

public int max(int... numbers). The varargs syntax `int... numbers` allows a method to accept zero or more integer arguments, which are then treated as an array inside the method. This is the standard Java syntax for variable-length argument lists, enabling the developer to pass any number of `int` values and compute the maximum.

Answer

public int max(int[]... numbers)

Answer

public int max(int numbers)

Answer

public int max(int[] numbers)

Question 10

Consider the following code:

int[] arr = new int[5];
for (int i = 0; i <= arr.length; i++) {
    arr[i] = i;
}
System.out.println(arr[0]);

What is the result?

Accepted Answer

An ArrayIndexOutOfBoundsException is thrown.. The loop condition `i <= arr.length` causes `i` to iterate from 0 to 5 inclusive. Since `arr` has indices 0 through 4, accessing `arr[5]` throws an `ArrayIndexOutOfBoundsException`. The exception occurs before `arr[0]` can be printed.

Answer

0

Answer

5

Answer

4

Question 11

A method that calculates the average of an array of doubles is defined as:

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

Which call is valid?

Accepted Answer

double avg = average(new double[]{1.0, 2.0, 3.0});. The method `average(double[] values)` expects a single argument of type `double[]`. The expression `new double[]{1.0, 2.0, 3.0}` creates an anonymous array object that matches the parameter type exactly, so the call compiles and runs correctly.

Answer

double avg = average(1.0, 2.0);

Answer

double avg = average(1.0, 2.0, 3.0);

Answer

double avg = average({1.0, 2.0, 3.0});

Question 12

Given the code:

int[] a = {1, 2, 3};
int[] b = {4, 5};
a = b;
b[0] = 99;
System.out.println(a[0]);

What is the output?

Accepted Answer

99. After `a = b;`, both `a` and `b` reference the same array object. Modifying `b[0]` to 99 also changes `a[0]` because they share the same underlying array. Therefore, `a[0]` prints 99.

Answer

3

Answer

1

Answer

4

Question 13

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 14

Which two of the following are valid ways to declare and initialize an array of integers? (Select two.)

Accepted Answer

int[] arr = new int[5];. It declares an integer array with a size of 5 using valid syntax, and the array is initialized with default values (0 for each element). In Java, `new int[5]` allocates memory for 5 integers and sets them to 0, which is a valid initialization.

Answer

int[] arr = new int[5]{1, 2, 3, 4, 5};

Answer

int[5] arr;

Answer

int arr = new int[5];

Question 15

Which three statements about method overloading are true? (Select three.)

Accepted Answer

Overloaded methods can have different return types.. Method overloading in Java allows methods to have different return types, provided they have different parameter lists. The return type alone is not sufficient to distinguish overloaded methods, but it can vary as long as the parameter lists differ.

Answer

Overloaded methods cannot have different access modifiers.

Answer

Overloaded methods can have the same parameter list as long as the return type differs.