Why when I pass an array, it changes value in the method? Amazing

Question

public class Test {
    public static void main(String[] args) {
        int[] arr = new int[5];
        arr[0]    = 1;
        method(arr);
        System.out.println(arr[0]);
    }

    private static void method(int[] array)
    {
        array[0] = 2;
    }
}

After invoking method, arr[0] becomes 2. Why is that!?

Answer 1

You can call set methods on objects passed to a method. Java is pass by value, which means that you can't replace an object in a method, though you can call set methods on an object.

If Java were pass by reference, this would pass:

public class Test {

public static void main(String[] args) {
    Test test = new Test();
    int j = 0;
    test.setToOne(j);
    assert j == 1;
}

public void setToOne(int i) {
    i = 1;
}
}

Answer 2

This is because Java uses Call by Object-Sharing* (for non-primitive types) when passing arguments to method.

When you pass an object -- including arrays -- you pass the object itself. A copy is not created.

If you mutate the object in one place, such as in the called method, you mutate the object everywhere! (Because an object is itself :-)

Here is the code above, annotated:

public static void main(String[] args)
{
    int[] arr = new int[5]; // create an array object. let's call it JIM.
    // arr evaluates to the object JIM, so sets JIM[0] = 1
    arr[0]    = 1;          
    System.out.println(arr[0]);  // 1
    method(arr);                 // fixed typo :-)
    // arr still evalutes to JIM
    // so this will print 2, as we "mutated" JIM in method called above
    System.out.println(arr[0]);  // 2
}

private static void method(int[] array)
{
    // array evaluates to the object JIM, so sets JIM[0] = 2
    // it is the same JIM object
    array[0] = 2;
}

Happy coding.

---

*Primitive values always have call-by-value semantics -- that is, a copy is effectively created. Since all primitive values are immutable this does not create a conflict.

Also, as Brian Roach points out, the JVM only implements call-by-value internally: the call-by-object-sharing semantics discussed above are implemented by passing the value of the reference for a given object. As noted in the linked wikipedia article, the specific terms used to describe this behavior differ by programming community.

---

Additional:

1. Pass by value or Pass by reference in Java? -- see aioobes answer and how it relates with Brian Roachs comments. And aioobe again: Does array changes in method?

2. Make copy of array Java -- note this only creates a "shallow" copy.

Answer 3

Java is Pass-by-Value, Dammit! http://javadude.com/articles/passbyvalue.htm

Answer 4

Because that's exactly what you're telling it to do. Java passes first by value, then by reference. You're passing in the array, but any modifications you make to that array will be reflected on any other accesses to that array.

A quick example for thought:

If within method you did array = null, no change would be visible from main - as you would be changing the local value of array without modifying anything on the reference.

Answer 5

method(arr[0]);

I think that's supposed to be

method(arr);

But anyway the value passed as argument to the method is the reference to the array and the local variable arr in the method is referencing the same array. So, within the method you are making changes to the same array.

Answer 6

Because when you are passing argument like int/double/char etc. they are the primitive data types and they are call by value - meaning their values are copied to a local variable in this method (that has the same name as the names in your argument) and changes made to them are only changes made to these local var -> does not affect your primitive type variables outside the method

however an array or any object data type is called by reference -> the argument pass their address(reference) to method. that way, you still have a local variable named by them which has the reference. You can change it to reference another array or anything. but when it is referencing an array, you can use it to set the value of the array. what it does is accessing the address it is referencing and change the content of the referenced place

Answer 7

Java is pass by value. What confuses people is that the 'value' of a variable that refers to an object allocated on the heap is a reference, so when you pass that, you pass the reference 'by value' and therefore it refers to the same object on the heap. Which means it doesn't matter from where you modify the referent; you're modifying the same thing.