Passing Arrays to Methods

When passing an array to a method, the reference of the array is passed to the method. Just as you can pass primitive type values to methods, you can also pass arrays to methods. For example, the following method displays the elements in an int array:

public static void printArray(int[] array) {
for (int i = 0; i < array.length; i++) {
System.out.print(array[i] + " ");
}
}

You can invoke it by passing an array. For example, the following statement invokes the printArray method to display 3, 1, 2, 6, 4, and 2.

printArray(new int[]{3, 1, 2, 6, 4, 2});

The preceding statement creates an array using the following syntax:

new elementType[]{value0, value1, ..., valuek};

There is no explicit reference variable for the array. Such array is called an anonymous array.

Java uses pass-by-value to pass arguments to a method. There are important differences between passing the values of variables of primitive data types and passing arrays.

• For an argument of a primitive type, the argument’s value is passed.
• For an argument of an array type, the value of the argument is a reference to an array; this reference value is passed to the method. Semantically, it can be best described as pass-by-sharing, that is, the array in the method is the same as the array being passed. Thus, if you change the array in the method, you will see the change outside the method.

Take the following code, for example:

public class Test {
public static void main(String[] args) {
int x = 1; // x represents an int value
int[] y = new int[10]; // y represents an array of int values
m(x, y); // Invoke m with arguments x and y
 System.out.println("x is " + x);
 System.out.println("y[0] is " + y[0]);
 }
public static void m(int number, int[] numbers) {
 number = 1001; // Assign a new value to number
 numbers[0] = 5555; // Assign a new value to numbers[0]
 }
}

x is 1
y[0] is 5555

You may wonder why after m is invoked, x remains 1, but y[0] become 5555. This is because y and numbers, although they are independent variables, reference the same array, as illustrated below. When m(x, y) is invoked, the values of x and y are passed to number and numbers. Since y contains the reference value to the array, numbers now contains the same reference value to the same array.

Arrays are objects in Java. The JVM stores the objects in an area of memory called the heap, which is used for dynamic memory allocation.

The program below shows the difference between passing a primitive data type value and an array reference variable to a method. The program contains two methods for swapping elements in an array. The first method, named swap, fails to swap two int arguments. The second method, named swapFirstTwoInArray, successfully swaps the first two elements in the array argument.

Before invoking swap
array is {1, 2}
After invoking swap
array is {1, 2}
Before invoking swapFirstTwoInArray
array is {1, 2}
After invoking swapFirstTwoInArray
array is {2, 1}

As shown below, the two elements are not swapped using the swap method. However, they are swapped using the swapFirstTwoInArray method. Since the parameters in the swap method are primitive type, the values of a[0] and a[1] are passed to n1 and n2 inside the method when invoking swap(a[0], a[1]). The memory locations for n1 and n2 are independent of the ones for a[0] and a[1]. The contents of the array are not affected by this call.

The parameter in the swapFirstTwoInArray method is an array. As shown above, the reference of the array is passed to the method. Thus the variables a (outside the method) and array (inside the method) both refer to the same array in the same memory location. Therefore, swapping array[0] with array[1] inside the method swapFirstTwoInArray is the same as swapping a[0] with a[1] outside of the method.