Java: For-Each loop and references [duplicate]

Answer 1

I added a comment into each example to clarify what's going on.

First example:

MyObject objects[] = new MyObject[6]; 
for(MyObject o: objects) { 

    // Construct a new object of type MyObject and assign a reference to it into 
    // the iteration variable o. This has no lasting effect, because the foreach
    // loop will automatically assign the next value into the iteration variable
    // in the the next iteration.
    o = new MyObject(); 
} 

Second example:

MyObject objects[] = new MyObject[6]; 
for(int i = 0; i < objects.length; i++) { 

    // Construct a new object of type MyObject and store a reference to it into the
    // i-th slot in array objects[]:
    objects[i] = new MyObject(); 
} 

Answer 2

First thing I want to mentioned is that non zero length arrays are always mutable.And inside the foreach loop

for(MyObject o in objects) 

what it does is in each iteration it works as following.

o = objects[0] // first iteration 
o = objects[1] // 2nd iteration

But in your case you assign another object to the reference o. Not to the objects in the array.Its simply like following.

ObjeMyObject objects[] = new MyObject[6];
 MyObject o = Object[0];
 0 = new MyObject();

But your original objects[0] still point to a null object.

Answer 3

Objects are only "copied" when you explicitly state you want to clone an object (and this object explicitly implements cloning feature).

You seem to confuse references and names.

In the first example, inside a foreach, local o variable refers to the area of memory some object from objects is stored. When you're doing o = new MyObject(), a new MyObject is initialized in some other area of memory, and then o reference is rewritten to point on this new area of memory.

In the second example, by writing objects[i] = new MyObject(), you're saying that objects[i] reference should be rewritten, not some local o variable.

Answer 4

Java works a little bit different than many other languages. What o is in the first example is simply a reference to the object.

When you say o = new MyObject(), it creates a new Object of type MyObject and references o to that object, whereas before o referenced objects[index].

That is, objects[index] itself is just a reference to another object in memory. So in order to set objects[index] to a new MyObject, you need to change where objects[index] points to, which can only be done by using objects[index].

Image: (my terrible paint skills :D)

Explanation: This is roughly how Java memory management works. Not exactly, by any means, but roughly. You have objects, which references A1. When you access the objects array, you start from the beginning reference point (A1), and move forward X blocks. For example, referencing index 1 would bring you to B1. B1 then tells you that you're looking for the object at A2. A2 tells you that it has a field located at C2. C2 is an integer, a basic data type. The search is done.

o does not reference A1 or B1, but C1 or C2. When you say new ..., it will create a new object and put o there (for example, in slot A3). It will not affect A1 or B1.

Let me know if I can clear things up a little.

Answer 5

The first one isn't allocating your array objects because foreach loops iterate over elements in a collection.

When you enter that foreach loop you don't have any elements in your collection, it is just an empty array initialized to size 6, so no objects will be added to your array.

Also, note that even if you had elements in the array the foreach loop wouldn't assign over top of them:

o = new MyObject();

basically means assign to o a new instance of MyObject, but o itself isnt part of the array objects it is only a temporary container used to iterate over the elements of the array, but in this case, there are none.

Answer 6

The short answer: yes, there is something like a copy going on.

The long answer: The Java foreach loop you posted is syntactic sugar for

MyObject objects[] = new MyObject[6];

Iterator<MyObject> it = objects.iterator();
while (it.hasNext()) {
   MyObject o = it.next();
   // The previous three lines were from the foreach loop

   // Your code inside the foreach loop
   o = new MyObject();
}

As the desugared version shows, setting a reference equal to something inside a foreach loop does not change the contents of the array.