Passing Arrays to Methods
Tags: java, programming, learning, beginners
Published: 2024-05-28 13:28:33

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:

n`ew 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.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mjp4n694vxg88q16fqfb.png)

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.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mg0q1njkg778n3gofcy3.png)

`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.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3hrvyf6czpkhxyl2srxe.png)

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.