Passing Arrays to Methods

// ── Method receives a copy of the reference — same underlying array: ──
public static void addTen(int[] array) {
    for (int i = 0; i < array.length; i++) {
        array[i] += 10;         // modifies the shared array object
    }
}

int[] values = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(values));  // [1, 2, 3, 4, 5]
addTen(values);
System.out.println(Arrays.toString(values));  // [11, 12, 13, 14, 15]
// Changes visible in caller — method modified the shared array.

// ── Reassigning the parameter does NOT affect the caller: ────────────
public static void tryToReplace(int[] array) {
    array = new int[]{99, 98, 97};  // local parameter now points elsewhere
    // The caller's array is unaffected — we only changed the local copy
    System.out.println("Inside method: " + Arrays.toString(array));
}

int[] data = {1, 2, 3};
tryToReplace(data);
System.out.println("After method:  " + Arrays.toString(data));
// Inside method: [99, 98, 97]  — local copy points to new array
// After method:  [1, 2, 3]     — caller's array unchanged

// ── Visual model: ─────────────────────────────────────────────────────
//
// Before call:   caller.values ──────────────────────▶ [1,2,3,4,5]
//
// During call:   caller.values ──────────────────────▶ [1,2,3,4,5]
//                method.array  ─────────────────────▲
//                                 (same object)
//
// After addTen:  caller.values ──────────────────────▶ [11,12,13,14,15]
//                (visible because they share the same array)
//
// After tryToReplace:
//                caller.data   ──────────────────────▶ [1,2,3] (unchanged)
//                method.array  ───▶ [99,98,97]  (new object — local only)

// ── Mutating method — documented to modify the array: ────────────────
/**
 * Sorts the array in ascending order.
 * This method modifies the given array in place.
 * @param array the array to sort — WILL BE MODIFIED
 */
public static void bubbleSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - i - 1; j++) {
            if (array[j] > array[j + 1]) {
                int temp    = array[j];
                array[j]    = array[j + 1];
                array[j + 1] = temp;
            }
        }
    }
}

int[] nums = {5, 2, 8, 1, 9};
bubbleSort(nums);
System.out.println(Arrays.toString(nums));  // [1, 2, 5, 8, 9] — modified

// ── Non-mutating method — reads but does not modify: ──────────────────
/**
 * Returns the sum of all elements.
 * The array is not modified.
 */
public static long sum(int[] array) {
    long total = 0;
    for (int value : array) {
        total += value;
    }
    return total;   // returns result, array unchanged
}

int[] data = {10, 20, 30, 40, 50};
System.out.println(sum(data));              // 150
System.out.println(Arrays.toString(data)); // [10, 20, 30, 40, 50] — unchanged

// ── Defensive copy — method that works on a copy internally: ──────────
/**
 * Returns the array sorted in ascending order.
 * The original array is NOT modified — this method works on a copy.
 */
public static int[] sortedCopy(int[] array) {
    int[] copy = Arrays.copyOf(array, array.length);  // defensive copy
    Arrays.sort(copy);
    return copy;    // return the sorted copy, original untouched
}

int[] original = {5, 2, 8, 1, 9};
int[] sorted   = sortedCopy(original);
System.out.println(Arrays.toString(original));  // [5, 2, 8, 1, 9] — unchanged
System.out.println(Arrays.toString(sorted));    // [1, 2, 5, 8, 9]

// ── Caller makes the copy when they need to preserve their data: ───────
int[] myData = {5, 2, 8, 1, 9};
bubbleSort(Arrays.copyOf(myData, myData.length));  // pass copy to mutating method
System.out.println(Arrays.toString(myData));        // [5, 2, 8, 1, 9] — safe

// ── Passing a 2D array — modifications visible to caller: ────────────
public static void multiplyAllByTwo(int[][] matrix) {
    for (int r = 0; r < matrix.length; r++) {
        for (int c = 0; c < matrix[r].length; c++) {
            matrix[r][c] *= 2;         // modifies shared inner arrays
        }
    }
}

int[][] grid = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
multiplyAllByTwo(grid);
System.out.println(Arrays.deepToString(grid));
// [[2, 4, 6], [8, 10, 12], [14, 16, 18]]

// ── Replacing an inner row — also visible to caller: ─────────────────
public static void zeroOutFirstRow(int[][] matrix) {
    matrix[0] = new int[matrix[0].length];  // replace inner array
    // new int[n] is filled with zeros by default
}

int[][] m = {{1, 2, 3}, {4, 5, 6}};
zeroOutFirstRow(m);
System.out.println(Arrays.deepToString(m));  // [[0, 0, 0], [4, 5, 6]]

// ── Partial array processing — pass index range parameters: ───────────
/**
 * Fills array[from] through array[to-1] with the given value.
 * Operates on the specified range of the caller's array.
 */
public static void fillRange(int[] array, int from, int to, int value) {
    for (int i = from; i < to; i++) {
        array[i] = value;
    }
}

int[] arr = {1, 2, 3, 4, 5, 6, 7};
fillRange(arr, 2, 5, 0);    // fill indices 2,3,4 with 0
System.out.println(Arrays.toString(arr));  // [1, 2, 0, 0, 0, 6, 7]

// ── Partial array via copy — clean method signature: ──────────────────
/**
 * Sorts the given array in place using standard sort.
 */
public static void sort(int[] array) {
    Arrays.sort(array);
}

int[] data = {5, 3, 8, 1, 6, 2};
// Sort only indices 1 through 4:
int[] subArray = Arrays.copyOfRange(data, 1, 5);    // copy the range
sort(subArray);                                      // sort the copy
System.arraycopy(subArray, 0, data, 1, subArray.length);  // put back
System.out.println(Arrays.toString(data));  // [5, 1, 3, 6, 8, 2]