Java数组复制

In questo tutorial, attraverso esempi, imparerai i diversi metodi disponibili per copiare array (unidimensionali e bidimensionali) in Java.

　In Java, possiamo copiare un array in un altro array. Ci sono diverse tecniche per copiare un array in Java.

1. Copiare l'array utilizzando l'operatore di assegnazione

Facciamo un esempio

class Main {
　　　　public static void main(String[] args) {
　　　　　　　
　　　　　　　　int[] numbers = {1, 2, 3, 4, 5, 6};
　　　　　　　　int[] positiveNumbers = numbers; // Copia dell'array
　　　　　　　　for (int number: positiveNumbers) {
　　　　　　　　　　　　System.out.print(number + ", ");
　　　　　　　　}
　　　　}
}

Output:

1, 2, 3, 4, 5, 6

　Nell'esempio sopra, abbiamo utilizzato l'operatore di assegnazione (=) per copiare un array chiamato numbers in un altro array chiamato positiveEnumbers.

　Questa tecnica è la più semplice eppure efficace. Tuttavia, questa tecnica ha un problema. Se modificiamo un elemento di un array, gli elementi corrispondenti degli altri array cambieranno. Ad esempio,

class Main {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] numbers = {1, 2, 3, 4, 5, 6};
　　　　　　　　int[] positiveNumbers = numbers; // Copia dell'array
　　　　　　
　　　　　　　　// Modifica il valore del primo array
　　　　　　　　numbers[0] = -1;
　　　　　　　　// Stampa il secondo array
　　　　　　　　for (int number: positiveNumbers) {
　　　　　　　　　　　　System.out.print(number + ", ");
　　　　　　　　}
　　　　}
}

Output:

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

　Ecco che possiamo vedere che abbiamo modificato un valore dell'array numbers. Quando stampiamo l'array positiveNumbers, possiamo vedere che il valore è cambiato di conseguenza.

Questo è perché entrambi gli array riferiscono allo stesso oggetto di array. Questo è dovuto alla copia superficiale. Per ulteriori informazioni sulla copia superficiale, visitaCopia superficiale。

Ora, per creare un nuovo oggetto di array durante la copia dell'array, è necessario effettuare una copia profonda invece di una copia superficiale.

2. Costruzione dell'array di copia utilizzando un ciclo

Facciamo un esempio:

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];
　　　　　　　　// Itera e copia gli elementi dal sorgente al destinazione
　　　　　　　　for (int i = 0; i < source.length; ++i) {
　　　　　　　　　　　　destination[i] = source[i];
　　　　　　　　}
　　　　　　
　　　　　　　　　// Converti l'array in una stringa
　　　　　　　　System.out.println(Arrays.toString(destination));
　　　　}
}

Output:

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

Nell'esempio sopra, abbiamo utilizzato un ciclo for per esplorare ogni elemento dell'array sorgente. In ogni iterazione, copiamo l'elemento dall'array source all'array destination.

In questo caso, l'array sorgente e l'array di destinazione riferiscono a oggetti diversi (copia profonda). Pertanto, se viene modificato un elemento di un array, l'elemento corrispondente dell'altro array rimarrà invariato.

Attenzione alla seguente istruzione,

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

In questo caso, il metodo toString() viene utilizzato per convertire l'array in una stringa.

3. Copia dell'array utilizzando il metodo arraycopy()

In Java,Classe SystemIl pacchetto contiene un metodo chiamato arraycopy() per copiare l'array. In confronto ai due metodi menzionati, questo metodo è una migliore scelta per copiare l'array.

　Il metodo consente di copiare una parte specifica dell'array sorgente nell'array di destinazione. Ad esempio,

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

Ecco qui,

• src - Array di sorgente che si desidera copiare

• srcPos - Posizione iniziale nel array di sorgente (indice)

• dest - Array di destinazione, dove verranno copiati gli elementi dal sorgente

• destPos - Posizione iniziale nel array di destinazione (indice)

• length - Numero di elementi da copiare

Facciamo un esempio:

//Utilizzo del metodo Arrays.toString()
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];
　　　　　　　　//Creazione dell'array n2 di lunghezza n1
　　　　　　　　int[] n2 = new int[n1.length];
　　　　　　
　　　　　　　　//Copia dell'intero array n1 nell'array n2
　　　　　　　　System.arraycopy(n1, 0, n2, 0, n1.length);
　　　　　　　　System.out.println("n2 = " + Arrays.toString(n2));　　
　　　　　　
　　　　　　　　　//Copia degli elementi dall'indice 2 dell'array n1
　　　　　　　　　//Copia degli elementi all'indice 1 dell'array n3
　　　　　　　　//Copia di 2 elementi
　　　　　　　　System.arraycopy(n1, 2, n3, 1, 2);
　　　　　　　　System.out.println("n3 = " + Arrays.toString(n3));　　
　　　　}
}

Output:

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

Nell'esempio sopra, abbiamo utilizzato il metodo arraycopy()

• System.arraycopy(n1, 0, n2, 0, n1.length) - Copia tutti gli elementi dell'array n1 nell'array n2

• System.arraycopy(n1, 2, n3, 1, 2) - I due elementi dell'array n1 iniziati dall'indice 2 vengono copiati all'indice 1 dell'array n3

Come puoi vedere, il valore iniziale predefinito degli elementi dell'array di tipo int è 0.

4. Copia dell'array utilizzando il metodo copyOfRange()

Possiamo anche utilizzareJava ArraysIl metodo copyOfRange() definito nella classe per copiare l'array. Ad esempio,

//Utilizzo dei metodi toString() e copyOfRange()
import java.util.Arrays;
class ArraysCopy {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] source = {2, 3, 12, 4, 12, -2};
　　　　　　
　　　　　　　　//Copia intera dell'array sorgente nel destinazione
　　　　　　　　int[] destination1 = Arrays.copyOfRange(source, 0, source.length);　　　　　　
　　　　　　　　System.out.println("destination1 = " + Arrays.toString(destination1));　
　　　　　　
　　　　　　　　// Copia dall'indice 2 all'indice 5 (escluso)　
　　　　　　　　int[] destination2 = Arrays.copyOfRange(source, 2, 5);　
　　　　　　　　System.out.println("destination2 = " + Arrays.toString(destination2));　　　
　　　　}
}

Risultato di output

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

Nell'esempio sopra, prestare attenzione alle seguenti righe:

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

In questo caso, vediamo che stiamo creando l'array destination1 e contemporaneamente copiamo l'array sorgente su di esso. Prima di chiamare il metodo copyOfRange(), non creiamo l'array destination1. Per ulteriori informazioni su questo metodo, visitareJava copyOfRange。

5. Copiare un array bidimensionale con un ciclo

Come per un array unidimensionale, possiamo anche utilizzare un ciclo for per copiare un array bidimensionale. Ad esempio,

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) {
　　　　　　　　　　　　//Assegna spazio per ogni riga dell'array di destinazione
　　　　　　　　　　　　destination[i] = new int[source[i].length];
　　　　　　　　　　　　for (int j = 0; j < destination[i].length; ++j) {
　　　　　　　　　　　　　　　　destination[i][j] = source[i][j];
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　
　　　　　　　　//Visualizza l'array di destinazione
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　
　　　　　　
　　　　}
}

Output:

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

Nella seguente programma, prestare attenzione alle seguenti righe:

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

In questo caso, usiamo il metodo deepToString() per fornire una migliore rappresentazione dell'array bidimensionale. Per ulteriori informazioni, visitareJava deepToString()。

Usare arraycopy() per copiare un array bidimensionale

Per semplificare il codice sopra, possiamo utilizzare System.arraycopy() per sostituire il ciclo interno, come si fa con un array unidimensionale. Ad esempio, ad esempio,

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) {
　　　　　　　　　　　　　//Assegna spazio per ogni riga dell'array di destinazione
　　　　　　　　　　　　　destination[i] = new int[source[i].length];
　　　　　　　　　　　　　System.arraycopy(source[i], 0, destination[i], 0, destination[i].length);
　　　　　　　　}
　　　　　
　　　　　　　　//Visualizza l'array di destinazione
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　　　　　
　　　　}
}

Output:

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

　Ecco come possiamo vedere che sostituendo il ciclo for interno con il metodo arraycopy(), possiamo ottenere lo stesso output.