Arrays and Methods practice questions

A method 'public static void modifyArray(int[] arr) { arr[0] = 99; }' is called with 'int[] myArray = {1,2,3}; modifyArray(myArray); System.out.println(myArray[0]);'. What is the output?

Trap 1: 1

The array is modified, so the value changes.

Trap 2: 0

Not the default value; the original element is overwritten.

Trap 3: Compilation error

The code compiles fine.

A
99
The method modifies the array element.
B
1
Why wrong: The array is modified, so the value changes.
C
0
Why wrong: Not the default value; the original element is overwritten.
D
Compilation error
Why wrong: The code compiles fine.

Question 2mediummatching

Match each control flow statement to its purpose.

Drag a concept onto its matching description — or click a concept then click the description.

Concepts

Matches

Executes a block based on a boolean condition

Selects one of many code blocks based on a value

Iterates a fixed number of times

Repeats while a condition is true

Executes at least once then repeats while condition true

Trap 1: if-else: Repeats a block of code a fixed number of times.

Incorrect — this describes a for loop, not if-else.

Trap 2: switch: Repeats a block of code as long as a condition is true.

Incorrect — this describes a while loop, not switch.

A
if-else: Executes a block of code based on a boolean condition.
This correctly defines the purpose of an if-else statement.
B
switch: Selects one of many code blocks based on the value of an expression.
This correctly defines the purpose of a switch statement.
C
for loop: Repeats a block of code a fixed number of times.
This correctly defines the purpose of a for loop.
D
while loop: Repeats a block of code as long as a condition is true.
This correctly defines the purpose of a while loop.
E
if-else: Repeats a block of code a fixed number of times.
Why wrong: Incorrect — this describes a for loop, not if-else.
F
switch: Repeats a block of code as long as a condition is true.
Why wrong: Incorrect — this describes a while loop, not switch.

Question 3hardmultiple choice

What is the output of the following code?

```java

public class FindIndex {
    public static int find(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) return i;
        }
        return -1;
    }

    public static void main(String[] args) {

int[] values = {3, 7, 2}; System.out.print(find(values, 7) + " " + find(values, 5));

}
}

```

Options: A: 0 -1 B: -1 -1 C: 1 -1 D: 1 1

Exhibit

Refer to the exhibit.
public class Search {
    public static int find(int[] data, int target) {
        for (int i = 0; i < data.length; i++) {
            if (data[i] == target) {
                return i;
            }
        }
        return -1;
    }
    public static void main(String[] args) {
        int[] values = {3, 7, 2, 9, 4};
        System.out.println(find(values, 7) + " " + find(values, 5));
    }
}

Trap 1: 0 -1

7 is at index 1, not 0.

Trap 2: -1 -1

7 is present.

Trap 3: 1 1

5 is not present.

A
0 -1
Why wrong: 7 is at index 1, not 0.
B
-1 -1
Why wrong: 7 is present.
C
1 -1
7 found at index 1, 5 not found returns -1.
D
1 1
Why wrong: 5 is not present.

Question 4mediummultiple choice

A developer writes a method that takes an int array and returns the sum of its elements. The method signature is: 'public static int sumArray(int[] arr)'. Which statement correctly calls this method?

Trap 1: int result = sumArray(true);

Passes a boolean, not an array.

Trap 2: int result = sumArray([1,2,3]);

Invalid syntax; use new int[]{...}.

Trap 3: int result = sumArray(5);

Passes an int, not an array.

A
int result = sumArray(new int[]{1,2,3});
This statement correctly invokes the `sumArray` method by providing an `int` array argument, precisely matching the `int[] arr` parameter defined in the method signature. The `new int[]{1,2,3}` syntax creates an anonymous integer array literal, which is then correctly passed to the static method. The method's `int` return value is subsequently assigned to the `int result` variable, ensuring type compatibility. This demonstrates the correct mechanism for passing an array argument to a static method.
B
int result = sumArray(true);
Why wrong: Passes a boolean, not an array.
C
int result = sumArray([1,2,3]);
Why wrong: Invalid syntax; use new int[]{...}.
D
int result = sumArray(5);
Why wrong: Passes an int, not an array.

Question 5easymultiple choice

Given the code snippet: 'int[] nums = {10, 20, 30, 40}; int sum = 0; for (int i = 0; i < nums.length; i++) { sum += nums[i]; }'. What is the value of sum after execution?

Trap 1: 30

Only sums first two elements.

Trap 2: 60

Only sums first three elements.

Trap 3: 140

Would require an extra element beyond array length.

A
100
Sums all four elements correctly.
B
30
Why wrong: Only sums first two elements.
C
60
Why wrong: Only sums first three elements.
D
140
Why wrong: Would require an extra element beyond array length.

Question 6easymultiple choice

Which of the following correctly uses the shorthand array initializer to declare and initialize an array of strings with the elements "A", "B", and "C"?

Trap 1: String[] arr = new String[] {"A", "B", "C"};

Correct. This uses anonymous array creation with 'new' to declare and initialize the array in one statement.

Trap 2: String[] arr = ("A", "B", "C");

Incorrect. Array initializers use curly braces, not parentheses.

Trap 3: String[] arr = ["A", "B", "C"];

Incorrect. Array initializers use curly braces, not square brackets.

A
String[] arr = new String[] {"A", "B", "C"};
Why wrong: Correct. This uses anonymous array creation with 'new' to declare and initialize the array in one statement.
B
String[] arr = ("A", "B", "C");
Why wrong: Incorrect. Array initializers use curly braces, not parentheses.
C
String[] arr = ["A", "B", "C"];
Why wrong: Incorrect. Array initializers use curly braces, not square brackets.
D
String[] arr = {"A", "B", "C"};
Correct. This uses the shorthand array initializer syntax with curly braces.

Question 7mediummultiple choice

A method 'public static int findMax(int[] numbers)' returns the maximum value in the array. Which implementation correctly handles an empty array by returning 0?

Trap 1: int max = 0; for(int n: numbers) if(n > max) max = n; return max;

No empty check; initializes max to 0; fails for all negative numbers.

Trap 2: int max = numbers[0]; for(int i=1; i<numbers.length; i++)…

No check for empty array; throws exception.

Trap 3: if(numbers.length == 0) return 0; int max = 0; for(int n: numbers)…

Initializes max to 0; fails if all numbers negative.

A
int max = 0; for(int n: numbers) if(n > max) max = n; return max;
Why wrong: No empty check; initializes max to 0; fails for all negative numbers.
B
int max = numbers[0]; for(int i=1; i<numbers.length; i++) if(numbers[i] > max) max = numbers[i]; return max;
Why wrong: No check for empty array; throws exception.
C
if(numbers.length == 0) return 0; int max = 0; for(int n: numbers) if(n > max) max = n; return max;
Why wrong: Initializes max to 0; fails if all numbers negative.
D
if(numbers.length == 0) return 0; int max = numbers[0]; for(int i=1; i<numbers.length; i++) if(numbers[i] > max) max = numbers[i]; return max;
Correctly handles empty and non-empty arrays.

Question 8hardmultiple choice

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?

Trap 1: The first element is swapped with itself.

No swap occurs due to exception.

Trap 2: A new array with length 2 is returned.

Method returns void.

Trap 3: The array remains unchanged.

An exception occurs before any change.

A
An ArrayIndexOutOfBoundsException is thrown.
Index 1 is out of bounds for length 1.
B
The first element is swapped with itself.
Why wrong: No swap occurs due to exception.
C
A new array with length 2 is returned.
Why wrong: Method returns void.
D
The array remains unchanged.
Why wrong: An exception occurs before any change.

Question 9mediummultiple choice

A developer writes a method that accepts a variable number of int arguments and returns their product. Which method signature correctly implements this?

Trap 1: public static int product(int[] nums)

This is not varargs; it requires an array argument.

Trap 2: public static int product(int nums...)

Invalid syntax; ellipsis after type.

Trap 3: public static int product(int..

Varargs must be the last parameter.

A
public static int product(int[] nums)
Why wrong: This is not varargs; it requires an array argument.
B
public static int product(int nums...)
Why wrong: Invalid syntax; ellipsis after type.
C
public static int product(int... nums)
Varargs correctly declared.
D
public static int product(int... nums, int extra)
Why wrong: Varargs must be the last parameter.

Question 10easymultiple choice

What is the output of the following code? int[] a = {1,2,3}; int[] b = a; b[0] = 99; System.out.println(a[0]);

Trap 1: 0

Default value not applicable.

Trap 2: 1

The array is shared, so a[0] becomes 99.

Trap 3: Compilation error

Code compiles fine.

A
0
Why wrong: Default value not applicable.
B
1
Why wrong: The array is shared, so a[0] becomes 99.
C
99
a and b refer to same array.
D
Compilation error
Why wrong: Code compiles fine.

Question 11hardmultiple choice

Which of the following correctly describes the effect of the method call 'Arrays.sort(myArray)' on an array of objects that do not implement Comparable?

Trap 1: The code does not compile because Arrays.sort requires a Comparator.

Arrays.sort(Object[]) compiles; exception at runtime.

Trap 2: The array is sorted using the natural order of the elements.

Natural order requires Comparable implementation.

Trap 3: The array is sorted using the order defined by the elements' equals…

Sorting uses compareTo, not equals.

A
The code does not compile because Arrays.sort requires a Comparator.
Why wrong: Arrays.sort(Object[]) compiles; exception at runtime.
B
A ClassCastException is thrown at runtime.
Elements must implement Comparable.
C
The array is sorted using the natural order of the elements.
Why wrong: Natural order requires Comparable implementation.
D
The array is sorted using the order defined by the elements' equals method.
Why wrong: Sorting uses compareTo, not equals.

Question 12easymulti select

Which TWO statements are true about method overloading in Java?

Trap 1: Overloaded methods must have the same number of parameters.

They can have different numbers.

Trap 2: Overloaded methods must have different return types.

Return type is not used for overloading.

Trap 3: Overloaded methods can have different names.

Must have the same name.

A
Overloaded methods must have the same number of parameters.
Why wrong: They can have different numbers.
B
Overloaded methods can have different parameter lists.
Different number or type of parameters.
C
Overloaded methods must have the same name.
By definition, overloading means same name.
D
Overloaded methods must have different return types.
Why wrong: Return type is not used for overloading.
E
Overloaded methods can have different names.
Why wrong: Must have the same name.

Question 13mediummulti select

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

Trap 1: The method can reassign the original array variable to a new array.

Only the copy of the reference is changed.

Trap 2: The method must return the array to reflect any changes.

Changes to elements are visible without returning.

Trap 3: The method cannot determine the size of the array.

The length field is accessible.

A
The method can reassign the original array variable to a new array.
Why wrong: Only the copy of the reference is changed.
B
The method can modify the elements of the array.
Changes to array elements affect the original array.
C
The method must return the array to reflect any changes.
Why wrong: Changes to elements are visible without returning.
D
The method receives a copy of the array reference.
Java passes object references by value.
E
The method cannot determine the size of the array.
Why wrong: The length field is accessible.

Question 14hardmulti select

Which THREE statements are correct about the 'main' method signature in Java?

Trap 1: It can be declared to return an int.

Must be void.

Trap 2: It can be named any valid identifier.

Must be named main.

A
It must be declared public.
JVM needs access to call it.
B
It can be declared to return an int.
Why wrong: Must be void.
C
It must be declared void.
The `main` method must be declared `void` because the Java Virtual Machine (JVM) specification strictly mandates this return type for the application's entry point. Deviating from `void` would prevent the JVM from recognising the method as the program's starting point, leading to a `NoSuchMethodError` or similar runtime issue. This requirement is a fundamental part of the `main` method's signature, ensuring all executable Java applications adhere to the standard `public static void main(String[] args)` definition.
D
It must be declared static.
JVM calls it without an instance.
E
It can be named any valid identifier.
Why wrong: Must be named main.

Question 15mediummultiple choice

A team is developing a Java application for an online store. The application has a class 'Inventory' that maintains an array of 'Product' objects. The method 'public void addProduct(Product p)' is intended to add a product to the array. The current implementation uses a fixed-size array of length 100. However, the business has grown, and the array may exceed its capacity. The team needs a solution that allows dynamic resizing without changing the method signature. Which approach should the team take?

Trap 1: Change the method signature to accept a Product[] array and copy…

Changes signature; breaks existing code.

Trap 2: Use a Collection<Product> as parameter and convert to array.

Changes parameter type; callers must change.

Trap 3: Change the return type to boolean and return false if array is full.

Changes return type; callers need modification.

A
Modify the method to use an ArrayList<Product> internally and keep the signature.
Allows dynamic resizing with same signature.
B
Change the method signature to accept a Product[] array and copy all elements.
Why wrong: Changes signature; breaks existing code.
C
Use a Collection<Product> as parameter and convert to array.
Why wrong: Changes parameter type; callers must change.
D
Change the return type to boolean and return false if array is full.
Why wrong: Changes return type; callers need modification.

Question 16hardmultiple choice

A developer is working on a Java program that processes sensor data. The data is stored in a 2D array 'double[][] readings', where each row represents a sensor and each column a time interval. The method 'public static double[] averagePerSensor(double[][] data)' should compute the average reading for each sensor (row) and return a 1D array of averages. The developer writes the following implementation: 'double[] result = new double[data.length]; for (int i = 0; i < data.length; i++) { double sum = 0; for (int j = 0; j < data[i].length; j++) { sum += data[i][j]; } result[i] = sum / data[i].length; } return result;'. However, the program sometimes throws a NullPointerException. What is the most likely cause?

Trap 1: The method returns a double[] but should return double[][].

Return type is correct.

Trap 2: The rows have different numbers of columns.

That is handled correctly by the inner loop.

Trap 3: The outer loop uses data[i].length instead of data.length.

Uses data.length correctly.

A
The method returns a double[] but should return double[][].
Why wrong: Return type is correct.
B
The rows have different numbers of columns.
Why wrong: That is handled correctly by the inner loop.
C
One or more rows in the 2D array are null.
Accessing length on null row causes NPE.
D
The outer loop uses data[i].length instead of data.length.
Why wrong: Uses data.length correctly.

Question 17mediumdrag order

Arrange the steps to create an object from a class in Java in the correct order.

Drag steps to the numbered slots on the right, or tap a step then tap a slot.

Steps

Order

1Step 1

2Step 2

3Step 3

4Step 4

5Step 5

Trap 1: Define the class, then instantiate the object, then declare a…

This is incorrect because you cannot assign an object reference to a variable that has not been declared yet; the variable must be declared before instantiation and assignment.

Trap 2: Declare a variable, then define the class, then instantiate the…

This is incorrect because the class must be defined before any variable of that type can be declared or any object instantiated; otherwise the class type is unknown.

Trap 3: Instantiate the object, then define the class, then declare a…

This is incorrect because you cannot instantiate an object without the class definition being available, and you cannot assign without a declared variable.

A
Define the class, then declare a variable, then instantiate with new, then assign to variable, then use the object.
This is the correct order because you must first define the class blueprint, then declare a reference variable to hold the object, then instantiate the object using 'new', assign the reference to the variable, and finally use the object via the variable.
B
Define the class, then instantiate the object, then declare a variable, then assign to variable, then use the object.
Why wrong: This is incorrect because you cannot assign an object reference to a variable that has not been declared yet; the variable must be declared before instantiation and assignment.
C
Declare a variable, then define the class, then instantiate the object, then assign to variable, then use the object.
Why wrong: This is incorrect because the class must be defined before any variable of that type can be declared or any object instantiated; otherwise the class type is unknown.
D
Instantiate the object, then define the class, then declare a variable, then assign to variable, then use the object.
Why wrong: This is incorrect because you cannot instantiate an object without the class definition being available, and you cannot assign without a declared variable.