System.arrayCopy() copies object or reference to object?

Question

I am having a final class NameAndValue. I copied an array of NameAndValue objects using System.arrayCopy() and when i changed a NameAndValue object in copied array, it gets reflected in the original array.

public final class NameAndValue
{
    public String name;
    public String value;

    public NameAndValue()
    {

    }

    public NameAndValue(String name,String value)
    {
        this.name = name;
        this.value = value;
    }
}

public class Main
{
    public static void main(String[] args)
    {
        NameAndValue[] nv = new NameAndValue[4];
        nv[0] = new NameAndValue("A", "1");
        nv[1] = new NameAndValue("B", "2");
        nv[2] = new NameAndValue("C", "3");
        nv[3] = new NameAndValue("D", "4");

        NameAndValue[] nv2 = new NameAndValue[4];
        System.arraycopy(nv, 0, nv2, 0, 2);
        nv2[2] = new NameAndValue("Y","25");
        nv2[3] = new NameAndValue("Z","26");

        for (int i = 0; i < 2; i++)
        {
            NameAndValue[] nv3 = new NameAndValue[4];
            System.arraycopy(nv2, 0, nv3, 0, 4);
            nv3[2].value = String.valueOf(i);
            nv3[3].value = String.valueOf(i+1);

            System.out.println(nv2[2].value);
            System.out.println(nv2[3].value);
            System.out.println("-----------------------");
        }
    }
}

I am getting output as,

0
1
-----------------------
1
2
-----------------------

I should have got output as 25 and 26 in all the cases,right?? why does it get changed??

Answer 1

System.arrayCopy() copies object or reference to object?

Reference, it's a shallow copy. Surprisingly, the docs don't say that explicitly, just implicitly as they only talk about copying array elements, not recursively copying the things they reference.

It's exactly the same as if you had this:

NameAndValue nv1 = new NameAndValue("A", "1");
NameAndValue nv2 = nv1;
nv2.value = "4";
System.out.println(nv1.value); // 4

Each array element is like the nv1 and nv2 vars above. Just as nv1 and nv2 reference (point to) the same underlying object, so do the array entries, including when those entries are copied from one array to another.

Answer 2

It gets changed because both arrays are referencing the same underlying objects still. You could assign a new object to a position in the array and it wouldn't get reflected in the other array, but if you make a modification to the object that both arrays are pointing to, then both will see it differently.

In this sense, it's pass "reference by value", rather than strictly pass by reference - but the effect you're seeing is because the reference remains the same.

Copies like this are almost always shallow copies in Java, unless explicitly stated otherwise. This is no exception.

Answer 3

As far as I know arraycopy is a shallow copy. Which means the new array will reference to the addresses of the elements in the old array. So if you adjust a value in one of them, it will reflect on both

Answer 4

System.arraycopy is a shallow copy. here's why:

it uses JNI to use something like memcpy() which just copies the pointers in memory. it's a very fast operation.

Answer 5

    int[] a = {1, 2, 3};
    int[] b = new int[3];
    System.arraycopy(a, 0, b, 0, 3);
    b[1] = 0;
    System.out.println(Arrays.toString(b));
    System.out.println(Arrays.toString(a));

The output is like this: [1, 0, 3] [1, 2, 3]