Cópia de Array Java

Neste tutorial, você aprenderá diferentes métodos disponíveis para copiar arrays (unidimensionais e bidimensionais) no Java, com a ajuda de exemplos.

　No Java, podemos copiar um array para outro array. Existem várias técnicas para copiar arrays no Java.

1Copiar array usando operador de atribuição

Vamos dar um exemplo

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

Saída:

1,　2,　3,　4,　5,　6

　No exemplo acima, usamos o operador de atribuição (=) para copiar um array chamado numbers para outro array chamado positiveEnumbers.

　Esta técnica é a mais simples e também eficaz. No entanto, esta técnica tem um problema. Se alterarmos um elemento de um array, o elemento correspondente do outro array também será alterado. Por exemplo,

class Main {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] numbers = {1,　2,　3,　4,　5,　6};
　　　　　　　　int[] positiveNumbers = numbers;　　　　//Copiar o array
　　　　　　
　　　　　　　　//Alterar o valor do primeiro array
　　　　　　　　numbers[0] =　-1;
　　　　　　　　//Imprimir o segundo array
　　　　　　　　for (int number : positiveNumbers) {
　　　　　　　　　　　　System.out.print(number　+　"");
　　　　　　　　}
　　　　}
}

Saída:

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

　Aqui, podemos ver que alteramos um valor do array numbers. Quando imprimimos o array positiveNumbers, podemos ver que o mesmo valor também foi alterado.

Isso é porque os dois arrays referenciam o mesmo objeto de array. Isso é devido à cópia superficial. Para obter mais informações sobre cópia superficial, acesseCópia superficial。

Agora, para gerar um novo objeto de array enquanto copia o array, precisamos fazer uma cópia profunda em vez de uma cópia superficial.

2Construção de array de cópia usando loop

Vamos dar um exemplo:

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ção e cópia de elementos do origem para o destino
　　　　　　　　for (int i = 0; i < source.length;　++i)　{
　　　　　　　　　　　　destination[i] = source[i];
　　　　　　　　}
　　　　　　
　　　　　　　　　//converter o array em uma string
　　　　　　　　System.out.println(Arrays.toString(destination));
　　　　}
}

Saída:

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

No exemplo acima, usamos um loop for para percorrer cada elemento do array de origem. Em cada iteração, copiamos o elemento do array source para o array destination.

Aqui, os arrays de origem e destino referenciam objetos diferentes (cópia profunda). Portanto, se um dos elementos de um array for alterado, o elemento correspondente do outro array também permanecerá inalterado.

Observe a seguinte instrução,

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

Aqui, o método toString() é usado para converter o array em uma string.

3usar o método arraycopy() para copiar arrays

No Java,classe Systemo pacote contém um método chamado arraycopy() para copiar arrays. Em comparação com os dois métodos acima, este método é uma maneira melhor de copiar arrays.

　o método permite que você copie uma parte específica do array de origem para o array de destino. Por exemplo,

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

aqui,

• src -o array de origem que você deseja copiar

• srcPos -a posição inicial (índice) no array de origem

• dest -o array de destino, a partir do qual os elementos serão copiados do array de origem

• destPos -a posição inicial (índice) no array de destino

• length -o número de elementos a serem copiados

Vamos dar um exemplo:

//usar o método 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];
　　　　　　　　//criar1com um comprimento de n2o array
　　　　　　　　int[] n2　= new int[n1.length];
　　　　　　
　　　　　　　　//copiar todo o n1o array é copiado para o n2
　　　　　　　　System.arraycopy(n1, 0, n2, 0, n1.length);
　　　　　　　　System.out.println("n2　= "　+　Arrays.toString(n2));　　
　　　　　　
　　　　　　　　　//a partir do n1o índice do array2copiar o elemento
　　　　　　　　　//o elemento será copiado para o n3o índice do array1
　　　　　　　　//serão copiados2elementos
　　　　　　　　System.arraycopy(n1,　2, n3,　1,　2);
　　　　　　　　System.out.println("n3　= "　+　Arrays.toString(n3));　　
　　　　}
}

Saída:

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

No exemplo acima, usamos o método arraycopy()

• System.arraycopy(n1, 0, n2, 0, n1.length) - copiar o n1todo o elemento do array é copiado para o n2o array

• System.arraycopy(n1, 2, n3, 1, 2 )-　 从索引2começando pelo n1dois elementos do array são copiados para o n3o array1no índice inicial

Como você vê, o valor inicial padrão do elemento de um array de tipo int é 0.

4. Usar copyOfRange() método para copiar array

Também podemos usarJava ArraysUsando o método copyOfRange() definido na classe para copiar arrays. Por exemplo,

//Usar toString() e copyOfRange() métodos
import java.util.Arrays;
class ArraysCopy {
　　　　public static void main(String[] args) {
　　　　　　
　　　　　　　　int[] source = {2,　3,　12,　4,　12,　-2};
　　　　　　
　　　　　　　　//Copiar todo o array de origem para o destino
　　　　　　　　int[] destination1　= Arrays.copyOfRange(source, 0, source.length);　　　　　　
　　　　　　　　System.out.println("destination1　= "　+　Arrays.toString(destination1));　
　　　　　　
　　　　　　　　//从索引2复制到5（不包含5)　
　　　　　　　　int[] destination2　= Arrays.copyOfRange(source,　2,　5);　
　　　　　　　　System.out.println("destination2　= "　+　Arrays.toString(destination2));　　　
　　　　}
}

Resultados de saída

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

No exemplo acima, note as seguintes linhas:

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

Aqui, podemos ver que estamos criando destination1Para copiar arrays ao mesmo tempo e copiar o array de origem para ele. Não criaremos destination antes de chamar o método copyOfRange()1Para obter mais informações sobre este método, acesseJava copyOfRange。

5. Usar laços para copiar array bidimensional

Como um array unidimensional, também podemos usar laços for para copiar arrays bidimensionais. Por exemplo,

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)　{
　　　　　　　　　　　　//Alocar espaço para cada linha do array de destino
　　　　　　　　　　　　destination[i]　=　new　int[source[i].length];
　　　　　　　　　　　　for (int j = 0; j < destination[i].length;　++j) {
　　　　　　　　　　　　　　　　destination[i][j] = source[i][j];
　　　　　　　　　　　　}
　　　　　　　　}
　　　　　
　　　　　　　　//Exibir o Array de Destino
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　
　　　　　　
　　　　}
}

Saída:

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

No programa acima, note as seguintes linhas:

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

Aqui, usamos o método deepToString() para fornecer uma melhor representação do array bidimensional. Para mais informações, acesseJava deepToString()。

Usar arraycopy() para copiar array bidimensional

Para simplificar o código acima, podemos usar System.arraycopy() para substituir o loop interno, como se fosse um array unidimensional. Por exemplo, por exemplo,

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)　{
　　　　　　　　　　　　　//Alocar espaço para cada linha do array de destino
　　　　　　　　　　　　　destination[i]　=　new　int[source[i].length];
　　　　　　　　　　　　　System.arraycopy(source[i],　0,　destination[i],　0,　destination[i].length);
　　　　　　　　}
　　　　　
　　　　　　　　//Exibir o Array de Destino
　　　　　　　　System.out.println(Arrays.deepToString(destination));　　　　　　
　　　　}
}

Saída:

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

　Aqui, podemos ver que, substituindo o loop interno por arraycopy(), obtemos a mesma saída.