Passing Arrays to Methods in Java

Direct Answer

Java is always pass-by-value. For an array parameter, the copied value is an array reference, so the caller and method initially refer to the same array. The method can change that array's elements. Reassigning the parameter changes only the method's local copy of the reference and does not redirect the caller's variable.

Code Example

These two methods look almost identical but behave completely differently, and running them is the fastest way to internalise the rule. Try it as a Java 17 console app and watch the two print statements.

public class ArrayPassDemo {

    // Modifies elements — the change IS visible to the caller
    static void doubleAll(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = arr[i] * 2; // reaches through the copied reference to the shared array
        }
    }

    // Reassigns the parameter — the caller's variable is NOT affected
    static void tryReplace(int[] arr) {
        arr = new int[]{1, 2, 3}; // only changes the local copy of the reference
        // the caller's original array is completely untouched
    }

    public static void main(String[] args) {
        int[] scores = {90, 85, 78};

        doubleAll(scores);
        System.out.println(scores[0]); // 180 — change visible, same heap object

        tryReplace(scores);
        System.out.println(scores[0]); // 180 — unchanged, reassignment did not escape
    }
}

The contrast is the whole answer: doubleAll reaches through the shared array reference and the change sticks, while tryReplace only rebinds its local copy of the address, so the caller's scores never moves.

Common Mistakes & Pitfalls

• Calling it pass-by-reference — the word interviewers wait for is "value". Java copies the reference by value; it never passes the variable itself.
• Expecting reassignment to escape — arr = new int[]{...} inside a method looks like it should replace the caller's array, but it only rebinds the local parameter; the caller is untouched.
• Forgetting that shared state cuts both ways — a helper that sorts or zeroes the array in place silently mutates the caller's data. If the caller still needs the original, pass arr.clone() or Arrays.copyOf(arr, arr.length).
• Assuming a method can "return" through the parameter — to give the caller a different array you must return it and reassign at the call site; writing arr = ... inside the method accomplishes nothing visible outside.