Passing an Array as a Parameter (4.6.A)

When you pass a primitive like int to a method, Java copies the value. Changes inside the method have no effect on the original variable.

public static void addFive(int x) {
    x = x + 5;  // only changes the local copy
}

int num = 10;
addFive(num);
System.out.println(num);  // still prints 10

Arrays work differently. An array variable stores a reference — a memory address pointing to the array's data. When you pass an array, Java copies the reference, not the array itself. Both the original variable and the parameter now point to the same array in memory.

public static void doubleAll(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = arr[i] * 2;
    }
}

int[] scores = {10, 20, 30};
doubleAll(scores);
System.out.println(scores[0]);  // prints 20 — the original array was modified

Visualizing the Reference

Both scores and arr point to the same memory location. Any change to arr[i] inside the method is a change to scores[i] outside it.

Reassigning the Parameter Has No Effect

public static void tryToReplace(int[] arr) {
    arr = new int[]{99, 99, 99};  // only changes local variable
}

int[] data = {1, 2, 3};
tryToReplace(data);
System.out.println(data[0]);  // still prints 1

Inside tryToReplace, arr is redirected to a brand new array. But data back in the calling code still points to the original {1, 2, 3} array — the reassignment only affected the local copy of the reference.

Returning an Array from a Method (4.6.B)

A method can return an array just like it returns any other value. Declare the return type with brackets: int[], String[], etc.

public static int[] makeDoubled(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        result[i] = arr[i] * 2;
    }
    return result;
}

Usage:

int[] original = {5, 10, 15};
int[] doubled = makeDoubled(original);
System.out.println(doubled[1]);   // prints 20
System.out.println(original[1]);  // still prints 10 — original unchanged

This pattern — create a new array inside the method, fill it, return it — is the standard way to produce a transformed version of an array without modifying the original.

// Returns a new array containing only the positive values
public static int[] positives(int[] arr) {
    int count = 0;
    for (int x : arr) {
        if (x > 0) count++;
    }
    int[] result = new int[count];
    int idx = 0;
    for (int x : arr) {
        if (x > 0) {
            result[idx] = x;
            idx++;
        }
    }
    return result;
}

Writing Complete Array Methods

Combining parameters and return values gives you full method design flexibility:

// Takes an array, returns a new array with each element replaced
// by the sum of itself and the next element.
// Last element wraps around to add arr[0].
public static int[] rollingSum(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length - 1; i++) {
        result[i] = arr[i] + arr[i + 1];
    }
    result[arr.length - 1] = arr[arr.length - 1] + arr[0];
    return result;
}

Summary

• Java always passes by value. For arrays, the value passed is a reference (memory address).
• Modifying array elements inside a method (arr[i] = x) does change the original array.
• Reassigning the parameter variable (arr = new int[3]) does not change the original array.
• Methods can return arrays by declaring a bracket return type: public static int[] method(...).
• The standard pattern for a non-destructive transform: create a new array inside the method, fill it, return it.

public static void addTen(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] += 10;
    }
}

int[] nums = {1, 2, 3};
addTen(nums);
System.out.println(nums[0]);

public static void replace(int[] arr) {
    arr = new int[]{99, 99, 99};
}

int[] vals = {1, 2, 3};
replace(vals);
System.out.println(vals[0]);

public static int[] doubled(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        result[i] = arr[i] * 2;
    }
    return result;
}

int[] original = {3, 6, 9};
int[] copy = doubled(original);
System.out.println(original[1] + " " + copy[1]);

public static void mystery(int[] arr) {
    arr[0] = arr[0] + arr[arr.length - 1];
    arr = new int[]{0, 0, 0};
}

int[] data = {4, 8, 12};
mystery(data);
System.out.println(data[0] + " " + data[1]);

public static int[] reverse(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        result[i] = arr[arr.length - 1 - i];
    }
    return result;
}

public static int[] reverse(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = arr[arr.length - 1 - i];
    }
    return arr;
}

public static void reverse(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        result[i] = arr[arr.length - 1 - i];
    }
}

public static int[] reverse(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length; i++) {
        result[i] = arr[i];
    }
    return result;
}

public static int[] shiftLeft(int[] arr) {
    int[] result = new int[arr.length];
    for (int i = 0; i < arr.length - 1; i++) {
        result[i] = arr[i + 1];
    }
    result[arr.length - 1] = arr[0];
    return result;
}

int[] a = {10, 20, 30, 40};
int[] b = shiftLeft(a);
System.out.println(b[0] + " " + b[3]);

public static void zeroOut(int[] arr) {
    arr = new int[arr.length];
}

public static void zeroOut(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = 0;
    }
}

public static int[] zeroOut(int[] arr) {
    return new int[arr.length];
}

public static void zeroOut(int[] arr) {
    for (int x : arr) {
        x = 0;
    }
}

public static int[] add(int[] a, int[] b) {
    int[] result = new int[a.length];
    for (int i = 0; i < a.length; i++) {
        result[i] = a[i] + b[i];
    }
    return result;
}

int[] x = {1, 2, 3};
int[] y = {4, 5, 6};
int[] z = add(x, y);
System.out.println(z[1] + " " + x[1]);