Copiar Matrizes Java

Matrizes de cópia Java

Neste tutorial, você aprenderá sobre as diferentes maneiras de copiar arrays (unidimensionais e bidimensionais) em Java com a ajuda de exemplos.

Em Java, podemos copiar um array em outro. Existem várias técnicas que você pode usar para copiar arrays em Java.

---

1. Copiando arrays usando o 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;    // copying arrays

        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 positiveNumbers .

Esta técnica é a mais fácil e também funciona. No entanto, há um problema com esta técnica. Se alterarmos os elementos de um array, os elementos correspondentes dos outros arrays também serão alterados. Por exemplo,

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 + ", ");
        }
    }
}

Saída :

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

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

É porque ambas as matrizes se referem ao mesmo objeto de matriz. Isso é por causa da cópia superficial. Para saber mais sobre cópia superficial, visite cópia superficial.

Agora, para criar novos objetos de matriz enquanto copia as matrizes, precisamos de uma cópia profunda em vez de uma cópia superficial.

---

2. Usando Looping Construct para Copiar Arrays

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];

        // 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));
    }
}

Saída :

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

No exemplo acima, usamos o for loop para percorrer cada elemento da matriz de origem. Em cada iteração, estamos copiando elementos do source array para o destino variedade.

Aqui, a matriz de origem e destino se refere a objetos diferentes (cópia profunda). Portanto, se os elementos de uma matriz forem alterados, os elementos correspondentes de outra matriz permanecerão inalterados.

Observe a afirmação,

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

Aqui, o método toString() é usado para converter um array em uma string. Para saber mais, visite o método toString() (documentação oficial do Java).

---

3. Copiando Arrays Usando o método arraycopy()

Em Java, a classe System contém um método chamado arraycopy() para copiar matrizes. Este método é uma abordagem melhor para copiar arrays do que os dois acima.

O arraycopy() O método permite que você copie uma parte especificada da matriz de origem para a matriz de destino. Por exemplo,

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

Aqui,

• src - matriz de origem que você deseja copiar
• srcPos - posição inicial (índice) na matriz de origem
• destino - array de destino onde os elementos serão copiados da fonte
• destPos - posição inicial (índice) na matriz de destino
• comprimento - número de elementos para copiar

Vamos dar um exemplo:

// 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));  
    }
}

Saída :

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

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

• System.arraycopy(n1, 0, n2, 0, n1.length) - elementos inteiros do n1 array são copiados para n2 matriz
• System.arraycopy(n1, 2, n3, 1, 2) - 2 elementos do n1 array começando no índice 2 são copiados para o índice a partir de 1 do n3 matriz

Como você pode ver, o valor inicial padrão dos elementos de um int tipo array é 0.

---

4. Copiando arrays usando o método copyOfRange()

Também podemos usar o método copyOfRange() definido na classe Java Arrays para copiar arrays. Por exemplo,

// 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));   
    }
}

Saída

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

No exemplo acima, observe a linha,

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

Aqui, podemos ver que estamos criando o destination1 array e copiando o source array para ele ao mesmo tempo. Não estamos criando o destination1 array antes de chamar o copyOfRange() método. Para saber mais sobre o método, visite Java copyOfRange.

---

5. Copiando arrays 2d usando loop

Semelhante ao array unidimensional, também podemos copiar o array bidimensional usando o for ciclo. 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) {

            // 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));  
      
    }
}

Saída :

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

No programa acima, observe a linha,

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

Aqui, o deepToString() é usado para fornecer uma melhor representação da matriz bidimensional. Para saber mais, visite Java deepToString().

---

Copiando arrays 2d usando arraycopy()

Para tornar o código acima mais simples, podemos substituir o loop interno por System.arraycopy() como no caso de uma matriz unidimensional. 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) {

             // 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));      
    }
}

Saída :

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

Aqui, podemos ver que obtemos a mesma saída substituindo o for interno loop com o arraycopy() método.