Java, why must I change the value of an array directly for it to be passed as reference?

Question

Why does changing directly a value in an parameter array becomes pass-by-reference but if I try to just pass the reference to the array it isn't pass-by-reference?

What is the most effective way to force it to be "pass-by-reference" in array = arrayII;, if there is one?

---

public static void main(String[] args) {
    // TODO code application logic here
    String [] array = {"Default1","Default2"};
    System.out.println("Start: " +" "+ array[0] + array[1]);
    test(array,false);
    System.out.println("false: " +" "+ array[0] + array[1]);
    test(array,true);
    System.out.println("true:  " +" "+ array[0] + array[1]);        
}

static void test(String[] array, boolean change){
    String [] arrayII = {"Changed1","Changed2"};    
    if (change){
        array[0] = "Changed1";
        array[1] = "Changed2";
    }
    else {
        array = arrayII;
    }
}

run:

Start:  Default1Default2
false:  Default1Default2
true:   Changed1Changed2
BUILD SUCCESSFUL (total time: 0 seconds)

Answer 1

Because array = arrayII; only updates the reference locally to the method. The method cannot update the value of the caller's reference to array (however, you could return arrayII and assign that in the caller).

Answer 2

Here, this example shows a different angle, and I think it will clear up the confusion. Let me know. Don't get scared by the code, just look at the output.

Code:

import java.util.Arrays;
public class Test {
public static void main(String[] args) {
    String[] array = {"Default1" ," Default2"};

    System.out.println("array memory address outside before: " + array);
    System.out.println();
    test(array);
    System.out.println();
    System.out.println("array memory address outside after: " + array); 
    System.out.println("array values: " + Arrays.toString(array)+ "\n//The original reference still points to the same memory and value have not changed");
}

private static void test(String[] array) {
    String[] arrayII = { "Changed1", "Changed2" };

    System.out.println();
    System.out.println("array values: " + Arrays.toString(array));
    System.out.println("arrayII values: " + Arrays.toString(arrayII));
    System.out.println();


    System.out.println("array memory address inside before:\t" + array);
    System.out.println("arrayII memory address inside before:\t" + arrayII);

    array = arrayII; // <<<<<<< The statement in question <<<<<<<<<

    System.out.println();
    System.out.println("array values: " + Arrays.toString(array));
    System.out.println("arrayII values: " + Arrays.toString(arrayII));
    System.out.println();

    System.out.println("array memory address inside after: " + array);
    System.out.println("arrayII memory address inside after: " + arrayII);
}
}

Output:

array memory address outside before:    [Ljava.lang.String;@3fae653c <<this

array values before: [Default1,  Default2]
arrayII values before: [Changed1, Changed2]

array memory address inside before:     [Ljava.lang.String;@3fae653c
arrayII memory address inside before:   [Ljava.lang.String;@24abbfad

array memory address inside after:      [Ljava.lang.String;@24abbfad
arrayII memory address inside after:    [Ljava.lang.String;@24abbfad

array values after: [Changed1, Changed2]
arrayII values after: [Changed1, Changed2]


array memory address outside after:     [Ljava.lang.String;@3fae653c <<this
array values after method: [Default1,  Default2]

The original reference still points to the same memory and values have not changed.

Notice how the memory addresses of array at the beginning and end are exactly the same? It's because the method is getting the pass-by-value of the memory address, not the values, which means that after the method, the pass-by-value can't communicate with what just happened to the version of array inside the method.

Answer 3

Your arrays are equal in content but array == array2 is false, because they point to different locations.

Java is pass-by-reference-value or pass-by-sharing. That means the method/function has a copy of your reference-value, but can never change the location your reference is pointing to, because it doesn't have the original reference, only a copy of the reference.

public static void main(String[] args) {
    // TODO code application logic here
    String [] array = {"array[0]","array[0]"};
    System.out.println("Start: " +" "+ array[0] + array[1]);
    test(array,false);
    System.out.println("false: " +" "+ array[0] + array[1]);
    test(array,true);
    System.out.println("true:  " +" "+ array[0] + array[1]);        
}

static void test(String[] array, boolean change){
    String [] arrayII = {"array2[0]","array2[1]"};    
    if (change){
        array[0] = "anotherValueForArray[0]";
        array[1] = "anotherValueForArray[1]";
    }
    else {
        array = arrayII;
    }
}

I modified your example to illustrate it better.

Answer 4

This has to do with how variables are stored in the computer in Java. "Shallow" variables (primitive data types like int or char) cannot be changed through a pass by reference, they are stored in the Stack. However, "deep" variables (like objects or arrays) are reference types which are also stored in the Stack but point to primitive data types (or even other objects) being stored in the Heap. If you were to pass an object or array as a parameter, it would make a local copy of the memory address for that object/array, but it would not be making a copy of the underlying values, it would receive the same variable access to the underlying values as the calling scope. Therefore, passing by reference via an object or array is the only way (in Java at least) to "cheat the system" and give the method extra control that otherwise shouldn't be possible from that scope.

To answer your question, the best way in Java to do a pass-by-reference is to create a wrapping object or array for your variable so that all of the underlying variables will be directly mutable in the method.

Example: Say you want to reassign a value to variable in the method OtherType.methodCall()... (variable is whatever datatype you want, even an array)

ValueType variable = 1;
ValueType[] wrapperForVariable = { variable }; //Wrap it up!
OtherType.methodCall(wrapperForVariable);
variable = wrapperForVariable[0];

variable == 2 // true!

...

public class OtherType {
    public static void methodCall(ValueType[] localVar) {
        // Stuff happens based on localVar[0]
        ...
        localVar[0] = 2;
    }
}

Result: variable has now been changed so that it has a different value, even though it was put into a method marked void!!

P.S. Strings are different because, while they are objects, under the hood they are actually immutable. Any change to a String actually makes a "deep" copy, meaning Strings would need wrappers too.

Answer 5

Java by default passes primitive data types like strings and ints by value and NOT by reference.

Your best bet for this code would be to return a value from the function test.

In a more elaborate program you could also make array a variable in a class.

Answer 6

It looks like the confusion here is on the distinction between pass-by-value and pass-by-reference. Java only supports pass-by-value. When you call test(array, someValue), the value of of the first argument is a reference to the array. So inside of test, when you overwrite the local value of array, you are overwriting a reference to the array you passed in. The data in the array you passed in, though, is untouched.

The two main solutions here are a) update elements in the array that was passed in, as you did in your example, or b) return arrayII, but update the code in your main method to say array = test(array);.

The tl;dr is that java only uses pass-by-value.