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

Question 1

Which TWO are valid ways to pass an array to a method in Java?

Accepted Answer

myMethod(new int[]{1,2,3});. `new int[]{1,2,3}` is an anonymous array creation expression that creates a new int array and passes it directly to the method. This syntax is valid in Java for passing an array literal without a variable. Option B is correct because it declares an array variable `arr` initialized with an array initializer `{1,2,3}` (which is allowed only in a declaration statement) and then passes that reference to the method, which is a standard way to pass an array.

Answer

myMethod(1, 2, 3);

Answer

myMethod(int[] {1,2,3});

Answer

myMethod(new int[5] {1,2,3,4,5});

Question 2

Which THREE statements are true about method overloading in Java?

Accepted Answer

The return type can be different, but it is not sufficient to differentiate overloaded methods.. In Java, method overloading requires methods to have different parameter lists. While the return type can be different, it alone is not sufficient to differentiate overloaded methods; the compiler uses the method signature (name + parameter types) to resolve overloads, and return type is not part of the signature.

Answer

Two methods with the same name, same parameter types, but different return types are overloaded.

Answer

Method overloading is resolved at runtime.

Question 3

What is the output when the main method is executed?

```java
public class Test {
    public static double add(double a, double b) {
        return a + b;
    }
    public static void main(String[] args) {
        System.out.println(add(5, 10));
    }
}
```

Accepted Answer

15.0. The code defines a single method `public static double add(double a, double b) { return a + b; }`. The main method calls `System.out.println(add(5,10));`. Java performs implicit widening conversion of the integer literals 5 and 10 to double, resulting in 15.0. Options 5.0 and 10.0 would be incorrect because the method adds the arguments. Option D is incorrect because there is no ambiguity — only one method matches after widening.

Answer

5.0

Answer

10.0

Answer

Compilation error: ambiguous method call

Question 4

What is printed when the main method runs?

Accepted Answer

5. The method `modifyArray` receives a reference to the array, and the assignment `arr = new int[]{100};` changes the local reference `arr` to point to a new array object. The original array in `main` remains unchanged, so `arr[0]` still prints 5. Java passes object references by value, meaning the reference itself is copied, and reassigning the local reference does not affect the caller's reference.

Answer

0

Answer

Compilation error: cannot assign new array to parameter

Answer

100

Question 5

A method is needed to return a new array where each element is doubled. Which method signature correctly accomplishes this?

Accepted Answer

public int[] doubleArray(int[] input). The method must return a new array with doubled values, so the return type must be `int[]` (an array of integers) and the parameter must be an `int[]` (the input array). This signature allows the method to accept an array, process each element, and return a new array of the same length with each element doubled.

Answer

public int doubleArray(int[] input)

Answer

public int[] doubleArray(int input)

Answer

public void doubleArray(int[] input)

Question 6

Given an array arr of length 5, which code snippet correctly creates a copy using System.arraycopy?

Accepted Answer

int[] copy = new int[arr.length]; System.arraycopy(arr, 0, copy, 0, arr.length);. It first declares and initializes a destination array `copy` of the same length as `arr`, then calls `System.arraycopy(arr, 0, copy, 0, arr.length)` to copy all 5 elements from `arr` into `copy`. This is the only option that uses `System.arraycopy` correctly, as the method requires a pre-existing destination array.

Answer

System.arraycopy(arr, 0, copy, 0, arr.length);

Answer

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

Answer

int[] copy = arr.clone();

Question 7

A method is declared as 'public void printElements(int... numbers)'. Which invocation will cause a compilation error?

Accepted Answer

printElements({1,2,3});. The syntax `{1,2,3}` is an array initializer that can only be used in a variable declaration or as part of an array creation expression (e.g., `new int[]{1,2,3}`). It cannot be passed directly as an argument to a varargs method. The varargs parameter `int... numbers` expects either a sequence of `int` values or an `int[]` array reference, but not an anonymous array initializer.

Answer

printElements(1, 2, 3);

Answer

printElements();

Answer

printElements(new int[]{1,2,3});

Question 8

A method 'public static void sort(int[] arr)' sorts the array in place. After calling 'sort(data)', the original array 'data' is changed. Which design issue does this demonstrate?

Accepted Answer

The method should return a new array to avoid side effects.. The method modifies the original array passed as an argument, which is a side effect. In Java, arrays are objects, and when passed to a method, the reference is passed by value, allowing the method to modify the array's contents. To avoid side effects and maintain immutability, the method should return a new sorted array instead of modifying the original.

Answer

The method should use a wrapper class for the array.

Answer

The method should be declared as void to indicate modification.

Answer

The method should use pass-by-value to avoid modification.

Question 9

A method 'public static double average(int[] numbers) { int sum = 0; for (int i = 0; i < numbers.length; i++) sum += numbers[i]; return sum / numbers.length; }' is called with array {10, 20, 30}. What change is needed to return the correct average?

Accepted Answer

Change 'sum / numbers.length' to '(double) sum / numbers.length'. The method performs integer division because both `sum` (int) and `numbers.length` (int) are integers, truncating the fractional part. Casting `sum` to `double` before division forces floating-point arithmetic, preserving the decimal value. For the array {10, 20, 30}, the correct average is 20.0, but integer division yields 20 (truncated from 20.0, though here it matches by coincidence; for non-integer averages like {10, 20, 31}, the error would be obvious).

Answer

Change the loop to for (int i = 1; i <= numbers.length; i++)

Answer

Change return type to int

Answer

Add a second parameter for the length

Question 10

Which method invocation is ambiguous given these overloaded methods? public void process(int[] a) and public void process(int... a)

Accepted Answer

process(new int[]{1, 2});. When you call process(new int[]{1, 2}), the compiler cannot determine whether to use the method with an int[] parameter or the varargs method (int... a). Both methods have the same signature after type erasure, and the argument is an int array, which matches both exactly, causing an ambiguity error.

Answer

process(1, 2);

Answer

process((int[]) null);

Answer

process();

Question 11

A method 'public static int[] generate() { int[] result = new int[10]; for (int i = 0; i < result.length; i++) result[i] = i * 2; return result; }' is defined. Which statement correctly calls this method and stores the result?

Accepted Answer

int[] data = generate();. The method `generate()` returns an `int[]` (an array of integers), and the assignment `int[] data = generate();` correctly declares a reference variable of type `int[]` and assigns the returned array to it. The method is static, so it can be called directly from a static context without an instance.

Answer

int[] data = new int[generate()];

Answer

int data = generate();

Answer

generate();

Question 12

Given 'int[] source = {1,2,3,4,5};' and 'int[] dest = new int[3];' which code correctly copies the first three elements from source to dest using System.arraycopy?

Accepted Answer

System.arraycopy(source, 0, dest, 0, 3);. `System.arraycopy(source, 0, dest, 0, 3)` copies exactly three elements starting from index 0 of the source array to index 0 of the destination array, matching the requirement. The `length` argument (3) specifies the number of array elements to copy, and the destination array has a capacity of 3, so no `ArrayIndexOutOfBoundsException` occurs.

Answer

System.arraycopy(source, 0, dest, 0, 5);

Answer

System.arraycopy(source, 1, dest, 0, 3);

Answer

System.arraycopy(source, 0, dest, 1, 3);

Question 13

A method 'public static void modify(int[][] matrix) { matrix[0][0] = 99; }' is called with 'int[][] values = {{1,2},{3,4}}; modify(values);'. What is the value of values[0][0] after the call?

Accepted Answer

99. Java passes object references by value. When 'modify(values)' is called, the reference to the 2D array is copied into the method parameter 'matrix'. Since 'matrix' points to the same array object, modifying 'matrix[0][0]' directly changes the original array's element, so 'values[0][0]' becomes 99.

Answer

Exception

Answer

1

Answer

0

Question 14

Which TWO are valid ways to declare and initialize an array of Strings?

Accepted Answer

String[] names = new String[]{"A", "B"};. It uses the valid syntax `new String[]{"A", "B"}` to both declare and initialize a String array in a single statement. This is the standard way to create an array with an anonymous array initializer when the declaration and initialization are combined.

Answer

String[] names = {"A", "B"}[];

Answer

String names[] = new String[2];

Answer

String[] names = {1, 2};

Question 15

Which TWO methods correctly modify the passed array in place?

Accepted Answer

public void zeroOut(int[] a) { for (int i = 0; i < a.length; i++) a[i] = 0; }. It directly modifies each element of the passed array by assigning 0 to a[i] within the loop. In Java, when an array is passed to a method, the method receives a reference to the same array object, so changes to the array's elements are reflected in the caller's array.

Answer

public void reset(int[] a) { a = new int[10]; }

Answer

public void swap(int[] a) { int[] temp = a; a = new int[1]; a[0] = temp[0]; }

Answer

public void setFirst(int[][] a) { a = new int[1][1]; a[0][0] = 5; }