APCSA学习疑问：Java中void方法如何更新main中的ArrayList及普通数组？

Great question—this is one of the most common "aha!" moments when learning Java's parameter passing rules, so let's break this down clearly:

1. Why your ArrayList void method works (even with Java's pass-by-value) #

First, let's clarify a key point: Java uses pass-by-value for all parameters. But when you pass an ArrayList (or any object), the "value" being passed is a copy of the reference to the ArrayList object in memory.

Here's the critical distinction:

• If you reassign the parameter inside the method (e.g., list = new ArrayList<>();), you're only changing the copied reference—this won't affect the original ArrayList in main.
• But if you modify the internal state of the object the reference points to (like sorting its elements, adding/removing items), you're altering the same object that the original reference in main points to. That's why your sorting method works!

Example of your working ArrayList code (simplified):

import java.util.ArrayList;
import java.util.Collections;

public class SortExample {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        
        sortArrayList(numbers);
        System.out.println(numbers); // Prints [2, 5, 8]—original list is updated!
    }

    public static void sortArrayList(ArrayList<Integer> list) {
        // We're modifying the existing ArrayList's internal elements, not reassigning the reference
        Collections.sort(list);
    }
}

2. Can you do the same with a regular array? #

Absolutely! Arrays in Java are also objects, so the same parameter passing logic applies. You just need to avoid reassigning the array parameter to a new array—instead, modify the existing array's elements or sort them directly.

Example with an int array:

import java.util.Arrays;

public class ArraySortExample {
    public static void main(String[] args) {
        int[] numbers = {5, 2, 8};
        
        sortArray(numbers);
        System.out.println(Arrays.toString(numbers)); // Prints [2, 5, 8]—original array is updated!
    }

    public static void sortArray(int[] arr) {
        // Modify the existing array's internal elements via the copied reference
        Arrays.sort(arr);
    }
}

Just like with ArrayLists, if you tried to do arr = new int[3]; inside the method, that would only change the local copy of the array reference, and the original array in main would stay untouched. But sorting or modifying individual elements works because you're operating on the same underlying object.

Glad to hear your ArrayList code is running smoothly now—this same logic translates directly to arrays once you get the hang of Java's pass-by-value with object references!

内容的提问来源于stack exchange，提问作者SPW