Getting burned by inconsistent passed by value rules in Java (1.5), was the choice of int [] just syntactic sugar to make array objects look like C/C++ arrays?

Question

I read something online that incorrectly stated that standard int [], etc arrays in Java were passed as copies, rather than passing references to the arrays, in analogy with the basic numerical types, and ended up overwriting an array when I thought I was modifying a copy. Can I chalk this up as a design choice to make things simpler to the target audience for Java circa mid-90s? (making objects look the same syntactically as C arrays, or are arrays really not of type "Object" in Java?)

That is, why didn't they just do something like:

Array array = new Array(<size>);

Additionally, why didn't they make everything (except literals) pass-by-reference to ensure consistency? (ints would then be passed as references to the int, not as the value of the int, so modifying a variable that's an argument of a method within that method would modify the value of the original variable, etc.)

Link to a discussion of pass-by-reference vs. pass-by-value in Java

Answer 1

Nothing is passed by reference in Java - but you need to know what the value of a variable is.

The value of a variable of type int[] is not an array. It's a reference to an array. All arrays are reference types, even if it's an array of primitives.

When you write:

int[] x = { 1, 2, 3, 4, 5 };
someMethod(x);

then the value of x is passed by value to someMethod. It's a reference to an array - the method can change the contents of the array, but it won't be able to change the value of x itself, which it could do if Java used pass-by-reference.

Once you understand that the value of any expression is either a reference or a primitive value, a lot of things become clearer. For example, take this code:

int[] x = { 1, 2, 3, 4, 5 };
int[] y = x;
y[0] = 10;
System.out.println(x[0]);

What would you expect the result to be? The assignment operator copies the value from the RHS to the LHS - so x and y are references to the same array. Therefore the final line prints out 10. This "copying the value" is exactly the same principle used for argument passing.

There's no inconsistency here - you just need to understand what's going on, and what pass-by-value and pass-by-reference really mean.

EDIT: I'm really surprised there's still any doubt about this.

From the Java Language Specification, section 8.4.1 (Formal Parameters):

When the method or constructor is invoked (§15.12), the values of the actual argument expressions initialize newly created parameter variables, each of the declared Type, before execution of the body of the method or constructor

That's practically the definition of pass by value semantics: the values of the arguments are used as the initial values of the parameters.

Those values may be references or they may be primitive values - it doesn't change the fact that it's the value which is passed.

EDIT: The definition you use, while badly expressed in my view, certainly does not mean that claiming Java passes everything by value is misleading.

It says, for pass by value:

This makes a copy of the variable and can be quite slow and inefficient if the variable is large like an array.

Note that it was talking about C and C++ (although C++ does have pass by reference as well, in fact). It talks about making a copy of the variable. That's exactly what Java does. The difference is that in Java, the value of the variable is always either a primitive value or a reference. It's never an object.

Once you understand that crucial point (and it's important for more than just argument passing) it's entirely straightforward to correctly say that Java passes everything by value. When a method or constructor is invoked, the arguments are evaluated and the values are used as the initial values of the parameters. That's pass by value, and that's what Java does for all parameters.

As for the PDF you linked to - that's a shamefully poor discussion of the topic, IMO. It makes a mess of what pass by reference means, it special-cases String for no good reason (String happens to be immutable, but other classes can be too) and it's generally wrong. Would it help if I gave some links supporting my point of view?

• Java is pass-by-value, dammit
• Pass by value, please
• Java passes references by value

There are hundreds more. You aren't the first one to be confused by this, but Java really does pass everything by value, even references.

Answer 2

Everything in Java is pass-by-value. Everything. In the case of Object types (which arrays are), what gets passed by value is the reference. No, that's not the same thing as pass-by-reference.

Answer 3

Yes, int[] is an Object. Yes, the syntax was to get C/C++ programmers in. No, it's not a poor design choice, the two statements are not contradictory.

Answer 4

From at least a performance perspective, it makes a lot of sense to pass arrays by reference. Otherwise you would need a lot of unnecessary copying.

That having said, I agree that there should be an immutable array object.

Answer 5

This is a common misconception about what it means for Java objects to be "passed by value." ALL Java objects, arrays, and primitives are passed by value, but in the case of objects and arrays, the value that's passed is in fact a pointer (or, if you'd like, reference) to the original object.

Here's the difference. In both Java and C++, I can write this function:

void myFunc(int[] arr) {
    arr[0] = 17;
}
myFunc(myLocalArray);

This, in either language, causes the value stored in arr[0] to be 17 both inside myFunc's "arr" variable and inside myLocalArray.

This is very exciting, of course, but has nothing whatsoever to do with "pass by reference."

Passing an array by reference means that, in a language like C++ (but NOT in Java), I can do this:

void myFunc(int[] arr) {
    arr = null;
}
myFunc(myLocalArray);

Here, I've completely replaced the myLocalArray object with an entirely different object (null, in this case, but it could be anything). I haven't merely modified the object (e.g., changed the value stored at a particular index), but rather have fundamentally erased all evidence that myLocalArray ever even pointed to a legitimate array.

In Java, that cannot ever be done.

So, the basic rule in Java is:

1. All edits WITHIN the object (e.g., calls to functions that alter state, direct alterations of state, changing values in an array, et cetera) act on the original object (i.e., in the calling function). No copy is ever made without you specifically making it.
2. Completely overwriting the local object with a new one will NEVER affect the object in the calling function.

Answer 6

Yeah sure. There is no denying that a memory address is also a value. So pass-by-reference really is just a special case of pass-by-value.

+1 for the most Filistine answers ever on SO.

BTW, I think I might also have a portion of an answer to

"why didn't they just make everything pass-by-reference to ensure consistent behaviour?"

In that case, how does the system deal with invocations where the arguments are literals, say 'result = f(2);' ?

Must that literal then not also be passed by reference ? And if that is so, would not that open up to the possibility of having your literals changing value by some invocation that updates the reference ? In which case the term 'literal' might become somewhat inappropriate, and a lot of possible code optimizations become impossible for the compiler to implement ?