Passing Arrays to Methods in Java

When you pass an array to a method in Java, you are handing over a reference to the array — not a copy of all its elements. The method receives an address that points to the same array in memory. This means the method can read every element, modify any element, sort the array, or fill it with new values — and every change is immediately visible to the caller.

This behaviour is directly useful: methods can be given an array, do their work on it, and the results are reflected without needing to return anything. It also introduces risk: a method that was only supposed to read an array can accidentally mutate it. Understanding exactly what happens when an array is passed — and when those changes are or are not visible — is one of the most tested topics in Java interviews.

What Happens When an Array Is Passed

Java always passes arguments by value. For arrays, the value being passed is the reference — the memory address of the array object. Both the caller's variable and the method's parameter end up pointing to the same array in memory.

Caller creates:   int[] marks = {85, 72, 91};
                                        |
                      marks ─────────►  [ 85 | 72 | 91 ]   (on heap)
                                        address: 0x5A2F

Passes to method: processMarks(marks)
                                        |
                      arr   ─────────►  [ 85 | 72 | 91 ]   (same address: 0x5A2F)

Both 'marks' and 'arr' point to the SAME array.
Changing arr[0] inside the method changes the same slot that marks[0] reads.

But if inside the method:  arr = new int[]{1, 2, 3};
                                        |
                      arr   ─────────►  [ 1 | 2 | 3 ]    (new array, new address)
                      marks ─────────►  [ 85 | 72 | 91 ]  (unchanged — still original)

Three rules follow from this:

1. ›Reading array elements inside a method works exactly as expected.
2. ›Modifying array elements (arr[i] = val) changes the original array — the caller sees this.
3. ›Reassigning the parameter (arr = new int[]{}) has no effect on the caller's variable.

Reading an Array in a Method

The simplest case — a method that reads an array without modifying it.

Output:
Array   : [72, 88, 91, 65, 78, 95, 83]
Max     : 95
Average : 81.71
Has 91? : true
Has 50? : false
After   : [72, 88, 91, 65, 78, 95, 83]

These methods only read the array — they never assign to arr[i]. The caller's array is untouched. Reading is always safe.

Modifying an Array in a Method

When a method writes to arr[i], it modifies the original array. The caller sees the change immediately after the method returns.

Output:
Before doubleAll  : [150, 300, 75, 450, 200]
After doubleAll   : [300, 600, 150, 900, 400]

Before zeroOut    : [85, 32, 91, 48, 72, 28, 95]
After zeroOut(<50): [85, 0, 91, 0, 72, 0, 95]

Before swap(0,4)  : [10, 20, 30, 40, 50]
After swap(0,4)   : [50, 20, 30, 40, 10]

Before normalise  : [4200.0, 8500.0, 6300.0, 3900.0, 7100.0]
After normalise   : 49.4 100.0 74.1 45.9 83.5

Every method modifies arr[i] directly. Because arr and the caller's variable point to the same array, every change is visible in the original variable after the method returns.

Reassignment Does Not Affect the Caller

This is the most misunderstood behaviour. Assigning arr = new int[]{...} inside a method only changes where the local parameter variable points. The caller's variable still holds the address of the original array.

Output:
=== Reassignment — no effect on caller ===
Before: [88, 72, 91, 65, 79]
  Inside (before): [88, 72, 91, 65, 79]
  Inside (after) : [1, 2, 3, 4, 5]
After : [88, 72, 91, 65, 79]

=== In-place fill — visible to caller ===
Before: [88, 72, 91, 65, 79]
After : [10, 20, 30, 40, 50]

tryReplace changes its local copy of the reference — but the caller's data variable still holds the original address. fillWithValues writes to each slot of the existing array — the caller's data reflects every change.

Returning Arrays From Methods

A method can create a new array, populate it, and return it to the caller. This is the correct pattern when a method should produce a new array without modifying the input.

Output:
Original       : [72, 91, 55, 88, 63, 79, 97, 45]
Sorted copy    : [45, 55, 63, 72, 79, 88, 91, 97]
Original after : [72, 91, 55, 88, 63, 79, 97, 45]

Above 60       : [72, 91, 88, 63, 79, 97]

Week A         : [10, 20, 30, 40, 50]
Week B         : [15, 25, 35, 45, 55]
Combined       : [25, 45, 65, 85, 105]

Reversed copy  : [45, 97, 79, 63, 88, 55, 91, 72]
Original after : [72, 91, 55, 88, 63, 79, 97, 45]

These methods return new arrays without touching their inputs. getSortedCopy is the canonical pattern — copy with Arrays.copyOf, sort the copy, return it. The caller gets a sorted version; the original is preserved for name-index mapping, display, or further processing.

Passing 2D Arrays to Methods

A 2D array passed to a method follows the same rules. The method receives a reference to the outer array, which holds references to inner row arrays. Modifying cell values (arr[i][j] = val) is visible to the caller. Reassigning the parameter or a row (arr = ... or arr[i] = ...) affects only the local copy.

Output:
Original:
     72   85   90
     88   61   78
     95   83   70

After multiplyAll(2) — original mutated:
    144  170  180
    176  122  156
    190  166  140

Original (2×3):
      1    2    3
      4    5    6

Transposed (3×2):
      1    4
      2    5
      3    6

Identity matrix after setDiagonal(1):
      1    0    0
      0    1    0
      0    0    1

multiplyAll and setDiagonal mutate cell values inside the shared 2D array — the caller sees the changes. transpose creates and returns a new 2D array — the original is untouched.

Mutation vs Reassignment — Comparison Table

Real-World Example — Student Report Processing System

The Business Problem

A school's result processing system receives student marks arrays from data entry. The system validates the input, computes statistics without modifying the original, applies a curve (grade boost) which does modify in-place, generates a sorted ranking copy for display, and identifies students who need intervention. Each operation is a separate method that correctly decides whether to mutate or create a copy.

Output:
=== Raw Marks ===
[72, 38, 91, 42, 85, 65, 55, 88]

[1] Valid marks array: true

── Class X-A Statistics ──
  Students  : 8
  Average   : 67.00
  Highest   : 91
  Lowest    : 38
  Passed    : 6/8
  Distinction: 4/8

After stats — original: [72, 38, 91, 42, 85, 65, 55, 88]

[3] Failed marks: [38, 42]

[4] Applying 5-mark grace curve...
Before: [72, 38, 91, 42, 85, 65, 55, 88]
After : [77, 43, 96, 47, 90, 70, 60, 93]

[5] Ranked (highest first): [96, 93, 90, 77, 70, 60, 47, 43]
    Original still         : [77, 43, 96, 47, 90, 70, 60, 93]

=== Final Grade Report ===
Student       Marks  Result
──────────────────────────────
Priya           77  DISTINCTION
Rohan           43  FAIL
Sneha           96  DISTINCTION
Karan           47  PASS
Ananya          90  DISTINCTION
Deepak          70  PASS
Meera           60  PASS
Suresh          93  DISTINCTION

The design is deliberate: printStatistics and isValidMarksArray are read-only — they never touch a single array slot. applyGraceCurve intentionally mutates in-place — the change is the feature. getRankedMarks and getFailedMarks return new arrays — the original order is preserved for the name-to-mark mapping that the final report depends on.

Best Practices

Document whether a method mutates its array parameter. A method named sort(int[] arr) clearly mutates. A method named getAverage(int[] arr) clearly does not. When the intent is ambiguous — like process(int[] arr) — add a Javadoc comment: @param arr — this array is modified in place. During code reviews at product companies, undocumented mutations on shared arrays are flagged as bugs before they cause them.

Return a new array when the input should remain unchanged. If the caller needs the original array intact after the method runs — for display, further processing, or name-index mapping — create a copy inside the method using Arrays.copyOf() and return the modified copy. Never silently modify a parameter unless that is the explicit purpose of the method.

Validate null and empty arrays at the start of every method. if (arr == null || arr.length == 0) is the standard guard. Without it, arr[0] on an empty array throws ArrayIndexOutOfBoundsException and arr.length on a null array throws NullPointerException. Both are preventable with one check.

Use Arrays.copyOf() inside the method to isolate mutations. If a method needs to sort or rearrange its input without affecting the caller, copy it with int[] work = Arrays.copyOf(arr, arr.length) and operate on work. Return the result. The caller never sees internal rearrangements.

Common Mistakes

Mistake 1 — Sorting the Original When Only a Sorted View Was Needed

This is the most common unintentional mutation in beginner code. The method was meant to display rankings — but it permanently rearranged the marks array, destroying its alignment with the names array.

Mistake 2 — Expecting Null to Be Handled Automatically

Mistake 3 — Reassigning the Parameter and Expecting Caller to See It

Mistake 4 — Modifying a 2D Array Row by Reassignment

Interview Questions

Q1. What happens when an array is passed to a method in Java?

Java passes the array by value — specifically, by value of the reference. The method receives a copy of the memory address pointing to the array. Both the caller's variable and the method's parameter refer to the same array object on the heap. Mutations to array elements (arr[i] = val) through the parameter are visible to the caller. Reassigning the parameter to a new array (arr = new int[]{}) only changes the local copy — the caller's variable still points to the original.

Q2. What is the difference between mutating an array in a method and reassigning the array parameter?

Mutating means changing the content of the existing array object — writing to arr[i], calling Arrays.sort(arr), or Arrays.fill(arr, 0). Because both caller and method reference the same object, mutations are visible to the caller. Reassigning means making the local parameter variable point to a different array — arr = new int[5]. This only changes where the local variable points; the caller's reference is unaffected and still holds the original address.

Q3. How do you pass an array to a method without allowing the method to modify the original?

Java has no built-in read-only array parameter. The two approaches are: pass a copy — method(Arrays.copyOf(original, original.length)) — so the method modifies the copy, not the original; or create the copy inside the method if the method is responsible for isolation. Using an immutable wrapper (Collections.unmodifiableList) does not apply to arrays directly. For sensitive scenarios, making a copy at the call site and passing the copy is the most explicit and clear approach.

Q4. Can a method return more than one array in Java?

Not directly — a method has a single return type. To return multiple arrays, wrap them in an object. A record is the cleanest option: record SplitResult(int[] passed, int[] failed) {}. The method returns a SplitResult and the caller accesses both arrays via result.passed() and result.failed(). A custom class works too. Returning a 2D array where each row is a result is also used but less readable.

Q5. What happens when a 2D array is passed to a method?

The method receives a copy of the reference to the outer array. This outer array holds references to inner row arrays. Modifying cell values — arr[i][j] = val — changes the shared object and is visible to the caller. Replacing a row — arr[i] = new int[]{} — only changes the local copy of that row's reference in the outer array; the caller's row reference is unaffected. Replacing the outer array — arr = new int[][]{} — has no effect on the caller.

Q6. Why should you validate an array parameter for null at the start of a method?

A null array passed to a method will throw NullPointerException the moment any operation is performed on it — .length, arr[i], or iterating with for-each. Since the JVM error message just says "null" without indicating which parameter was null or which method received it, debugging becomes harder. Checking if (arr == null) at the start produces a controlled failure with a meaningful message, or a graceful fallback. Combined with arr.length == 0, this guard prevents the two most common array method crashes.

FAQs

Can a method receive an array and add elements to it?

No. Arrays have a fixed size set at creation. A method receiving an array cannot add elements — there are no empty slots to fill beyond arr.length - 1. The method can overwrite existing elements, or return a new larger array created with Arrays.copyOf(arr, arr.length + n). For dynamic addition, ArrayList is the correct type to pass instead of a raw array.

Does sorting an array inside a method affect the original?

Yes. Arrays.sort(arr) sorts the elements of the array object that arr points to — which is the same object the caller's variable points to. The sorted order is permanent and visible to the caller after the method returns. If you need to sort without modifying the original, copy first: int[] copy = Arrays.copyOf(arr, arr.length); Arrays.sort(copy);

Can varargs and arrays be used interchangeably?

A varargs method void process(int... arr) accepts the same call as void process(int[] arr) when you pass an existing array — the compiler treats a varargs parameter as a regular int[] inside the method. The difference is at the call site: varargs lets callers pass individual values directly — process(1, 2, 3) — without constructing an array. An array parameter forces the caller to build the array first. Inside both methods, the parameter behaves identically as int[].

How do you copy a 2D array to prevent mutations from propagating?

Arrays.copyOf(matrix, matrix.length) copies the outer array but shares inner row references — a shallow copy. Mutations to cell values still propagate because the rows are shared. For a true deep copy, copy each row: for (int i = 0; i < matrix.length; i++) copy[i] = Arrays.copyOf(matrix[i], matrix[i].length). This creates independent row arrays — mutations to one copy do not affect the other.

Is it better to mutate an array parameter or return a new array?

Returning a new array is generally safer and more predictable — the caller retains control of the original and is not surprised by side effects. Mutating in-place is acceptable when the method's explicit purpose is to transform the array, the name clearly signals mutation (sort, fill, update), and performance matters (avoiding array allocation). In production code, pure functions that return new arrays are easier to test, compose, and reason about. In-place mutation is used when performance is the priority or when the API contract explicitly states it.

Summary

Passing an array to a method in Java passes the reference — the memory address — by value. Element mutations through that reference are visible to the caller. Reference reassignment is invisible to the caller. This single rule explains every behaviour you will encounter when writing methods that work with arrays.

The production rule that prevents most bugs: decide upfront whether a method should mutate its input or return a new array, and make that decision visible through the method name and documentation. sortInPlace(int[] arr) signals mutation. getSortedCopy(int[] arr) signals that the original is preserved. When callers can predict the effect of a method call from its name alone, bugs from unintended array mutation disappear.

For interviews, be ready to explain the difference between element mutation and parameter reassignment with a concrete memory diagram, demonstrate the pattern of copying before sorting, explain how to validate null and empty arrays, and describe when to mutate in place versus return a new array.

What to Read Next