I'll assume that you've in fact created two separate arrays to begin
with, and that it was your intention to copy from the *second* element
(at position 1).

What I wrote earlier about array references is true of references to
*any* object. The above call to System.arraycopy() does basically
this:

 for (int i=1; i<size; i++) {
   Lmatrix[i] = Pmatrix[i];
 }

If your arrays contain object references, then each array holds its
own copy of the references afterwards and can be manipulated
independently of the other, but the referred objects themselves will
be shared.

In that case, you need to make copies of the objects (not copies of
the object references) when you copy the array elements. Exactly how
you do that depends on what the objects are (and needs their support),
but look into using clone() or a copy constructor.

It might look something like this:

 for (int i=1; i<size; i++) {
   Lmatrix[i] = Pmatrix[i].clone();
 }

or this:

 for (int i=1; i<size; i++) {
   Lmatrix[i] = new Gurka(Pmatrix[i]);
 }

/gordon

If you create a new array Lmatrix (i.e. int[] Lmatrix = new int[..]) the
two arrays "aren't linked".

Have a look at the following:

int[] array1 = {5, 4, 3, 2, 1, 0};
int[] array2 = new int[array1.length];
System.arraycopy(array1, 0, array2, 0, array1.length);
for (int i=0; i<array1.length; i++) array1[i] = i;
for (int i=0; i<array1.length; i++) System.out.print(array1[i]+" ");
System.out.println();
for (int i=0; i<array2.length; i++) System.out.print(array2[i]+" ");
System.out.println();

The output is:
0 1 2 3 4 5
5 4 3 2 1 0

Now have a look at this (which only differs in the second line):

int[] array1 = {5, 4, 3, 2, 1, 0};
int[] array2 = array1;
System.arraycopy(array1, 0, array2, 0, array1.length);
for (int i=0; i<array1.length; i++) array1[i] = i;
for (int i=0; i<array1.length; i++) System.out.print(array1[i]+" ");
System.out.println();
for (int i=0; i<array2.length; i++) System.out.print(array2[i]+" ");
System.out.println();

The output is:
0 1 2 3 4 5
0 1 2 3 4 5

The reason is that in the first example you have two arrays, the first
referenced by array1 and the second referenced by array2. In the second
example you have just one array because array2 references the same array
as array1. (There is no second array created but only the reference to
the first array is copied.)

One more comment on the line
System.arraycopy(Pmatrix, 1, Lmatrix, 1, size)
Notice that the first element of an array has the index 0 not 1.

Greetings

Alex

If the element type of the arrays is (also) a reference type, then copying the
arrays and then fiddling with the contents, would have about the same effect
as your first attempt.  When copying objects that contain objects (that
contain objects), a so-called "deep copy" will recursively copy every bit of
information.  The java.util.Arrays class provides methods for doing this.