Java-kopieerarrays

In deze tutorial leer je aan de hand van voorbeelden hoe je arrays (zowel eendimensionaal als tweedimensionaal) in Java kunt kopiëren.

In Java kunnen we de ene array naar de andere kopiëren. Er zijn verschillende technieken die u kunt gebruiken om arrays in Java te kopiëren.

1. Arrays kopiëren met de toewijzingsoperator

Laten we een voorbeeld nemen,

class Main {
    public static void main(String[] args) {
       
        int [] numbers = {1, 2, 3, 4, 5, 6};
        int [] positiveNumbers = numbers;    // copying arrays

        for (int number: positiveNumbers) {
            System.out.print(number + ", ");
        }
    }
}

Uitvoer :

1, 2, 3, 4, 5, 6

In het bovenstaande voorbeeld hebben we de toewijzingsoperator gebruikt (= ) om een ​​array te kopiëren met de naam getallen naar een andere array met de naam positiveNumbers .

Deze techniek is de gemakkelijkste en het werkt ook. Er is echter een probleem met deze techniek. Als we elementen van de ene array veranderen, veranderen de corresponderende elementen van de andere arrays ook. Bijvoorbeeld,

class Main {
    public static void main(String[] args) {
      
        int [] numbers = {1, 2, 3, 4, 5, 6};
        int [] positiveNumbers = numbers;    // copying arrays
      
        // change value of first array
        numbers[0] = -1;

        // printing the second array
        for (int number: positiveNumbers) {
            System.out.print(number + ", ");
        }
    }
}

Uitvoer :

-1, 2, 3, 4, 5, 6

Hier kunnen we zien dat we één waarde van de getallen . hebben gewijzigd reeks. Wanneer we de positiveNumbers . afdrukken array, kunnen we zien dat dezelfde waarde ook is gewijzigd.

Dit komt omdat beide arrays naar hetzelfde arrayobject verwijzen. Dit komt door de ondiepe kopie. Ga voor meer informatie over oppervlakkig kopiëren naar oppervlakkig kopiëren.

Om nu nieuwe array-objecten te maken terwijl we de arrays kopiëren, hebben we een diepe kopie nodig in plaats van een ondiepe kopie.

2. Looping Construct gebruiken om arrays te kopiëren

Laten we een voorbeeld nemen:

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
      
        int [] source = {1, 2, 3, 4, 5, 6};
        int [] destination = new int[6];

        // iterate and copy elements from source to destination
        for (int i = 0; i < source.length; ++i) {
            destination[i] = source[i];
        }
      
         // converting array to string
        System.out.println(Arrays.toString(destination));
    }
}

Uitvoer :

[1, 2, 3, 4, 5, 6]

In het bovenstaande voorbeeld hebben we de for . gebruikt loop om elk element van de bronarray te doorlopen. In elke iteratie kopiëren we elementen uit de bron array naar de bestemming array.

Hier verwijzen de bron- en bestemmingsarray naar verschillende objecten (diepe kopie). Als elementen van een array worden gewijzigd, blijven de corresponderende elementen van een andere array dus ongewijzigd.

Let op de verklaring,

System.out.println(Arrays.toString(destination));

Hier wordt de methode toString() gebruikt om een ​​array om te zetten in een string. Ga voor meer informatie naar de methode toString() (officiële Java-documentatie).

3. Arrays kopiëren met de methode arraycopy()

In Java bevat de klasse System een ​​methode met de naam arraycopy() om arrays te kopiëren. Deze methode is een betere benadering om arrays te kopiëren dan de bovenstaande twee.

De arraycopy() methode stelt u in staat om een ​​gespecificeerd gedeelte van de bronarray naar de doelarray te kopiëren. Bijvoorbeeld,

arraycopy(Object src, int srcPos,Object dest, int destPos, int length)

Hier,

• src - bronarray die u wilt kopiëren
• srcPos - startpositie (index) in de bronarray
• bestemming - bestemmingsmatrix waar elementen uit de bron worden gekopieerd
• destPos - startpositie (index) in de bestemmingsarray
• lengte - aantal te kopiëren elementen

Laten we een voorbeeld nemen:

// To use Arrays.toString() method
import java.util.Arrays;

class Main {
    public static void main(String[] args) {
        int[] n1 = {2, 3, 12, 4, 12, -2};
      
        int[] n3 = new int[5];

        // Creating n2 array of having length of n1 array
        int[] n2 = new int[n1.length];
      
        // copying entire n1 array to n2
        System.arraycopy(n1, 0, n2, 0, n1.length);
        System.out.println("n2 = " + Arrays.toString(n2));  
      
        // copying elements from index 2 on n1 array
        // copying element to index 1 of n3 array
        // 2 elements will be copied
        System.arraycopy(n1, 2, n3, 1, 2);
        System.out.println("n3 = " + Arrays.toString(n3));  
    }
}

Uitvoer :

n2 = [2, 3, 12, 4, 12, -2]
n3 = [0, 12, 4, 0, 0]

In het bovenstaande voorbeeld hebben we de arraycopy() . gebruikt methode,

• System.arraycopy(n1, 0, n2, 0, n1.length) - hele elementen uit de n1 array worden gekopieerd naar n2 reeks
• System.arraycopy(n1, 2, n3, 1, 2) - 2 elementen van de n1 array vanaf index 2 worden gekopieerd naar de index vanaf 1 van de n3 reeks

Zoals u kunt zien, is de standaard beginwaarde van elementen van een int type array is 0.

4. Arrays kopiëren met de methode copyOfRange()

We kunnen ook de methode copyOfRange() gebruiken die is gedefinieerd in de klasse Java Arrays om arrays te kopiëren. Bijvoorbeeld,

// To use toString() and copyOfRange() method
import java.util.Arrays;

class ArraysCopy {
    public static void main(String[] args) {
      
        int[] source = {2, 3, 12, 4, 12, -2};
      
        // copying entire source array to destination
        int[] destination1 = Arrays.copyOfRange(source, 0, source.length);      
        System.out.println("destination1 = " + Arrays.toString(destination1)); 
      
        // copying from index 2 to 5 (5 is not included) 
        int[] destination2 = Arrays.copyOfRange(source, 2, 5); 
        System.out.println("destination2 = " + Arrays.toString(destination2));   
    }
}

Uitvoer

destination1 = [2, 3, 12, 4, 12, -2]
destination2 = [12, 4, 12]

Let in het bovenstaande voorbeeld op de regel,

int[] destination1 = Arrays.copyOfRange(source, 0, source.length);

Hier kunnen we zien dat we de destination1 . maken array en het kopiëren van de bron array er tegelijkertijd naar toe. We maken niet de destination1 array voordat u de copyOfRange() . aanroept methode. Ga voor meer informatie over de methode naar Java copyOfRange.

5. 2D-arrays kopiëren met Loop

Net als bij de eendimensionale array, kunnen we de 2-dimensionale array ook kopiëren met behulp van de for lus. Bijvoorbeeld,

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
      
        int[][] source = {
              {1, 2, 3, 4}, 
              {5, 6},
              {0, 2, 42, -4, 5}
              };

        int[][] destination = new int[source.length][];

        for (int i = 0; i < destination.length; ++i) {

            // allocating space for each row of destination array
            destination[i] = new int[source[i].length];

            for (int j = 0; j < destination[i].length; ++j) {
                destination[i][j] = source[i][j];
            }
        }
     
        // displaying destination array
        System.out.println(Arrays.deepToString(destination));  
      
    }
}

Uitvoer :

[[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

Let in het bovenstaande programma op de regel,

System.out.println(Arrays.deepToString(destination);

Hier, de deepToString() methode wordt gebruikt om een ​​betere weergave van de 2-dimensionale array te geven. Ga voor meer informatie naar Java deepToString().

2D-arrays kopiëren met arraycopy()

Om de bovenstaande code eenvoudiger te maken, kunnen we de binnenste lus vervangen door System.arraycopy() zoals in het geval van een eendimensionale array. Bijvoorbeeld,

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
      
        int[][] source = {
              {1, 2, 3, 4}, 
              {5, 6},
              {0, 2, 42, -4, 5}
              };

        int[][] destination = new int[source.length][];

        for (int i = 0; i < source.length; ++i) {

             // allocating space for each row of destination array
             destination[i] = new int[source[i].length];
             System.arraycopy(source[i], 0, destination[i], 0, destination[i].length);
        }
     
        // displaying destination array
        System.out.println(Arrays.deepToString(destination));      
    }
}

Uitvoer :

[[1, 2, 3, 4], [5, 6], [0, 2, 42, -4, 5]]

Hier kunnen we zien dat we dezelfde uitvoer krijgen door de binnenste for . te vervangen lus met de arraycopy() methode.