Transfer mechanism and modification strategy of array parameters in Java methods

In Java, when objects (including arrays) are used as method parameters, the "value passing" mechanism is used, that is, a copy of the object reference is passed. This means that there is no way inside a method to change the original reference held by the caller by reassigning parameters. However, the method can modify the element contents of the array through this reference, or "replace" the original array by returning a new array and reassigning it by the caller.

Understanding Java's parameter passing mechanism: the essence of value passing

In Java, all parameter passing is "pass-by-value". This core concept is crucial to understanding how methods interact with arrays or other objects.

• Basic data types (such as int, double, boolean, etc.) : When a basic data type is passed as a parameter, the method receives a copy of the value. Any modifications to this copy inside the method will not affect the original variable.
• Object types (including arrays) : When object types (such as String, ArrayList, custom class instances, and arrays) are passed as parameters, the method receives a copy of the object reference . Both this copy reference and the original reference point to the same object in memory. This means:
  • Methods can access and modify the object's internal state through this reference copy (for example, changing the values ​​of elements in an array, or calling methods on the object to change its properties).
  • However, if the method internally reassigns the parameter to a new object (for example, array = new int[]{...}), this will only change the object pointed to by the method's local parameter, without affecting the original reference held by the caller. The original reference still points to the original object.

Common Mistake: Trying to modify the original reference by reassigning a parameter

Take the following code as an example, which is a typical misunderstanding scenario:

 public class ArrayModificationDemo {

    public static void modifyArrayReference(int[] array) {
        // This line creates a new array object and points the method's local 'array' parameter to it // But it will not affect the object pointed to by 'myArray' in the main method array = new int[]{1, 2, 3, 4, 5}; 
        System.out.println("Inside the method (modifyArrayReference), the third element of the array: " array[2]);
    }

    public static void main(String[] args) {
        int[] myArray = {1, 1, 1, 1, 1};
        System.out.println("Before calling, the third element of the array in the main method: " myArray[2]); // Output: 1

        modifyArrayReference(myArray);

        // Although modifyArrayReference internally reassigns 'array',
        // 'myArray' in the main method still points to the original array System.out.println("In the main method, the third element of the array after the call: " myArray[2]); // Still output: 1
    }
}

Running results:

 Before calling, the third element of the array in the main method: 1
Inside the method (modifyArrayReference), the third element of the array: 3
In the main method, the third element of the array after calling: 1

Explanation: The modifyArrayReference method receives a copy of the myArray reference variable in the main method. When array = new int[]{1, 2, 3, 4, 5}; is executed, it creates a brand new array object and points the array parameter inside the method to this new array. At this time, myArray in the main method still points to the original {1,1,1,1,1} array. Therefore, the main method still prints the third element of the original array, which is 1.

Strategy 1: Modify the element content of the array (modify in place)

If your goal is to modify the contents of the passed-in array, rather than replace the entire array object, you can access and modify the elements of the array directly through the passed-in reference. Since the method parameters and the caller both point to the same array object, modifications to the object will be reflected synchronously.

 public class ArrayModificationDemo {

    public static void modifyArrayElements(int[] array) {
        if (array != null && array.length >= 5) {
            array[0] = 10;
            array[1] = 20;
            array[2] = 30; // Modify the third element array[3] = 40;
            array[4] = 50;
        }
        System.out.println("Inside the method (modifyArrayElements), the third element of the array: " array[2]);
    }

    public static void main(String[] args) {
        int[] myArray = {1, 1, 1, 1, 1};
        System.out.println("Before calling, the third element of the array in the main method: " myArray[2]); // Output: 1

        modifyArrayElements(myArray);

        // At this time, the content of the array pointed to by 'myArray' in the main method has been modified System.out.println("In the main method, the third element of the array after the call: " myArray[2]); // Output: 30
    }
}

Running results:

 Before calling, the third element of the array in the main method: 1
Inside the method (modifyArrayElements), the third element of the array: 30
In the main method, the third element of the array after calling: 30

Explanation: The array parameter in the modifyArrayElements method and the myArray variable in the main method both point to the same int[] array object in memory. When modifyArrayElements modifies the array element via array[2] = 30;, it directly changes the internal state of that shared object. Therefore, when the main method subsequently accesses myArray[2], it will see the modified value 30.

Strategy 2: Return a new array object

If the method really needs to create an entirely new array and wants the caller to use this new array to replace its original array reference, the method should create the new array and return it. The caller needs to explicitly assign the returned new array to its own reference variable.

 public class ArrayModificationDemo {

    public static int[] createAndReturnNewArray(int[] originalArray) {
        // You can do some processing based on originalArray, or directly create and return a new array int[] newArray = new int[]{1, 2, 3, 4, 5};
        System.out.println("Inside the method (createAndReturnNewArray), the third element of the new array: " newArray[2]);
        return newArray; // Returns a reference to the newly created array}

    public static void main(String[] args) {
        int[] myArray = {1, 1, 1, 1, 1};
        System.out.println("Before calling, the third element of the array in the main method: " myArray[2]); // Output: 1

        // The key step: assign the new array reference returned by the method to myArray
        myArray = createAndReturnNewArray(myArray); 

        // At this point, myArray has pointed to the new array returned by the method System.out.println("In the main method, the third element of the array after the call: " myArray[2]); // Output: 3
    }
}

Running results:

 Before calling, the third element of the array in the main method: 1
Inside the method (createAndReturnNewArray), the third element of the new array: 3
In the main method, the third element of the array after calling: 3

Explanation: The createAndReturnNewArray method creates a new int[] array and references it as the return value. In the main method, the line myArray = createAndReturnNewArray(myArray); reassigns the myArray variable to a reference to the new array returned by the method. In this way, myArray now points to the new {1,2,3,4,5} array, thus realizing the "replacement" of the array.

Summary and Notes

• Java is always pass-by-value : whether it is a primitive type or an object reference, what is passed is a copy of them.
• Characteristics of reference copies :
  • You can use a reference copy to modify the contents of the object it points to (for example, array[index] = value), and this modification is visible to all places that hold references to the object.
  • You cannot change the object pointed to by the original reference held by the caller through a reference copy. If you reassign a reference copy inside a method (for example, array = new int[]{...}), this only affects the local reference inside the method, not the caller.
• How to "modify" an array reference :
  • Modify elements in place : If the purpose is to change the existing content of the array, just operate the array elements directly through the passed in reference.
  • Replace the entire array : If the purpose is to let the caller use a completely new array object, the method should return the new array and the caller should explicitly reassign its reference variable.
• Best practice : When designing a method, make it clear whether the method expects to modify an existing object (in-place) or to create and return a new object. Clear API design helps avoid confusion.

The above is the detailed content of Transfer mechanism and modification strategy of array parameters in Java methods. For more information, please follow other related articles on the PHP Chinese website!