4

I read somewhere that System.arraycopy does create a new copy for primitive data types and shallow copy for object references.

so, that I started the experiment that with below code

//trying with primitive values
int a[] ={1,2,3};
int b[] = new int[a.length];
System.arraycopy(a,0,b,0,a.length);
b[0] = 9;
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));
//now trying with object references
Object[] obj1 = {new Integer(3),new StringBuffer("hello")};
Object[] obj2 = new Object[obj1.length];
System.arraycopy(obj1,0,obj2,0,obj1.length);
obj1[1] = new StringBuffer("world");
System.out.println(Arrays.toString(obj1));
System.out.println(Arrays.toString(obj2));

and the output was

[1, 2, 3]
[9, 2, 3]
[3, world]
[3, hello]

But what I expected was

[1, 2, 3]
[9, 2, 3]
[3, world]
[3, world]

from the above code, I understood that System.arraycopy does deep copy for object references If so, how obj1[0] == obj2[0] gives true

gajapathy p
  • 113
  • 1
  • 13
  • "Deep copy for primitives". How can you do a deep copy for primitives, when by definition, they do not refer to anything deeper? – RealSkeptic Apr 05 '17 at 06:32

4 Answers4

5

You have a misconception.

Once you do 

obj1[1] = new StringBuffer("world");

You have replaced the reference in obj1[1]. Now the two arrays contain different references to different objects.

If you want to see that what was copied was the actual reference, you should try instead:

obj1[1].setLength(3);

Now both obj1[1] and obj2[1] should contain the string hel, because you did not replace the reference but rather changed the content.

RealSkeptic
  • 33,993
  • 7
  • 53
  • 79
4

System.arraycopy does shallow copy, which means it copies Object references when applied to non primitive arrays.

Therefore after System.arraycopy(obj1,0,obj2,0,obj1.length);, obj1[0]==obj2[0] and obj1[1]==obj2[1], since both arrays hold references to the same Objects.

Once you assign a new value to obj1[1], obj1[1] no longer refers to the same StringBuffer instance as obj2[1]. That's why the outputs of Arrays.toString(obj1) and Arrays.toString(obj2) are different.

If instead of 

obj1[1] = new StringBuffer("world");

you would write

obj1[1].setLength(0);
obj1[1].append("world");

both print statements would output [3, world], since both arrays would still refer to the same StringBuffer instance.

Eran
  • 387,369
  • 54
  • 702
  • 768
1

No, it's shallow copy for references.

First you create the reference to a new StringBuffer("hello"), then you make a shallow copy of that. So you've got 1 StringBuffer, but 2 references to it.

Finally you replace the other reference with a completely new StringBuffer("world").

Kayaman
  • 72,141
  • 5
  • 83
  • 121
0

I understood that System.arraycopy does deep copy for object references If so, how obj1[0] == obj2[0] gives true

No, you are wrong, it doesn't perform the deep copy. Because obj1[0] == obj2[0] refer the same integer objects (i.e., references stored in the arrays at index '0') inside the both the arrays, so you are getting the answer as true. Also, you can compare obj1[1] == obj2[1] which returns false, because both the StringBuffer references are different.

Also, the other point is that System.arrayCopy does only a shallow copy (simply copies the references/values from one array to another), you can refer here on this.

Community
  • 1
  • 1
Vasu
  • 21,832
  • 11
  • 51
  • 67
  • `obj1[0] == obj2[0] compares the integer values` - actually that's wrong. `obj1[0]` and `obj2[0]` refer to the same `Integer` object as a result of the arraycopy statement, which is why `obj1[0] == obj2[0]`. If you add a `obj2[0] = new Integer(3);` after the arraycopy statement, `obj1[0] == obj2[0] ` will no longer be true, even though both would still have the same value (3). – Eran Apr 05 '17 at 06:46