Clonar arrays Java

Farkhanda Athar 14 abril 2022 18 novembro 2021 Java Java Array
  1. Cópia manual do array Java usando o loop for em Java
  2. Usando Arrays.copyOf() para clonar um array Java
  3. Usando Arrays.copyOfRange() para clonar um array Java
  4. Usando Object.clone() para clonar um array Java
  5. Usando System.arraycopy() para clonar um array Java
Clonar arrays Java

Os arrays Java podem ser copiados em outro array das seguintes maneiras.

  • Usando a atribuição de variável: esta técnica tem suas desvantagens porque qualquer mudança em um elemento de array reflete em ambos os lugares.
  • Crie um array do mesmo tamanho e copie todos os elementos.
  • Faça uso da técnica de clone para o array. Os métodos de clonagem criam uma nova matriz de tamanho semelhante.
  • Faça uso da técnica System.arraycopy(). arraycopy é um método para copiar uma parte específica de um array.

Cópia manual do array Java usando o loop for em Java

Normalmente, no momento em que queremos copiar variáveis ​​como a e b, realizamos a operação de cópia da seguinte maneira:

public class Main 
{ 
     public static void main(String[] args) 
    { 
         int IArray[] = {24,45,56}; 
       
        System.out.println("Before assignment the values of IArray[] are:"); 
        for (int i=0; i<IArray.length; i++) 
             System.out.print(IArray[i] + " ");
 
        int CArray[] = new int[IArray.length]; 
 
        CArray =  IArray;     
        CArray[1]++; 
 
        System.out.println("\nElements of IArray[]:"); 
        for (int i=0; i<IArray.length; i++) 
              System.out.print(IArray[i] + " "); 
 
        System.out.println("\nElements of CArray[]:"); 
        for (int i=0; i<CArray.length; i++) 
              System.out.print(CArray[i] + " "); 
    } 
}

Resultado:

Before assignment the values of IArray[] are:
24 45 56 
Elements of IArray[]:
24 46 56 
Elements of CArray[]:
24 46 56 

Não será eficaz quando você aplicar esse mesmo procedimento a arrays.

Usando Arrays.copyOf() para clonar um array Java

Este método que é Arrays.copyOf() é útil para uso interno do procedimento System.arraycopy(). Embora não seja tão eficaz quanto a cópia do array, ele pode duplicar um total ou parte dos arrays, semelhante ao método de cópia do array. O método copyOf() é um elemento do pacote java.util e faz parte da classe Arrays. A ideia básica por trás desse método é:

public class Main
{
    public static void main(String args[])
    {

        int[] OArray = new int[] {11, 12 ,13};

        System.out.println("Original Arrays elements are");
        for (int i = 0; i < OArray.length; i++)
            System.out.print(OArray[i] + " ");


        int[] CArray = Arrays.copyOf(OArray, 5);

        
        CArray[3] = 22;
        CArray[4] = 66;

        System.out.println("\nNew array after copying and modification are:");
        for (int i = 0; i < copy.length; i++)
            System.out.print(copy[i] + " ");
    }
}

Resultado:

Original Arrays elements are
11 12 13 
New array after copying and modification are
11 12 13 22 66 

Aqui,

  • original: o array que será copiado para o array recém-criado.
  • newLength: comprimento do array copiado que será retornado.

Portanto, este método cria uma cópia exata de array fornecida como o primeiro argumento para o tamanho especificado preenchendo ou truncando o comprimento adicionando 0 para criar a nova matriz. Isso significa que se o tamanho do array copiado for maior do que o que estava originalmente no array 0, os elementos restantes são substituídos por s.

Usando Arrays.copyOfRange() para clonar um array Java

O método Arrays.copyOfRange() é especialmente projetado para copiar partes de arrays. Método toCopyOf() semelhante, o método utiliza a técnica System.arraycopy(). A ideia básica por trás do procedimento Arrays.copyOfRange() pode ser descrita como a seguir:

import java.util.Arrays;

class Main { 
     public static void main(String args[]) 
    { 
         int IArray[] = { 100,200,300,400,500 }; 
 
        int[] CArray = Arrays.copyOfRange(IArray, 2, 6); 
        System.out.println("Array within the index range : " + 
        Arrays.toString(CArray));
 
       int[] CArray1 = Arrays.copyOfRange(IArray, 4, IArray.length + 3); 
 
       System.out.println("Array copied within the indexed range: " + Arrays.toString(CArray1));
 
    } 
}

Resultado:

Array within the index range : [300, 400, 500, 0]
Array copied within the indexed range: [500, 0, 0, 0]

Aqui,

  • original: a matriz de um intervalo sendo copiado.
  • from: o índice do array a ser copiado, inclusive.
  • to: o índice do intervalo que deve ser copiado e exclusivo.

Usando Object.clone() para clonar um array Java

Os arrays Java implementam internamente uma interface clonável, portanto, é fácil clonar os arrays Java. É possível clonar arrays unidimensionais e bidimensionais. Se você copiar um array unidimensional, ela criará uma réplica extensa dos elementos de array que copia os valores.

Por outro lado, ao copiar arrays bidimensionais ou multidimensionais, você obtém uma pequena cópia dos elementos que é criada, ou seja, a única informação de referência é copiada. Este processo de clonagem é realizado usando o método clone() oferecido aos arrays.

class Main 
{     
     public static void main(String args[])  
    { 
     int NArray[] = {50,100,150,200,250,300}; 
 
     int CArray[] = NArray.clone(); 
 
    System.out.println("Original Num Array are:");
    for (int i = 0; i <NArray.length; i++) { 
            System.out.print(NArray[i]+" "); 
        } 
    System.out.println();
 
    System.out.println("Cloned Num Array are:");
    for (int i = 0; i <CArray.length; i++) { 
        System.out.print(CArray[i]+" "); 
        } 
    System.out.println("\n");
 
    System.out.print("NArray == CArray = "); 
    System.out.println(NArray == CArray); 
    } 
}

Resultado:

Original Num Array are:
50 100 150 200 250 300 
Cloned Num Array are:
50 100 150 200 250 300 

NArray == CArray = false

Usando System.arraycopy() para clonar um array Java

A classe System do Java fornece uma opção chamada ArrayCopy que permite copiar elementos de um array para outro. O modelo mais comum para este método é:

class Main {  
    public static void main(String[] args) {  
        //declaring a source array  
        char[] Oarray = { 'I','L','o','v','e','M','y','C','o','u','n','t','r','y'}; 
  
        char[] Farray = new char[14];  
 
        System.arraycopy(Oarray, 0, Farray, 0,14);
        System.out.println("Origional Array Elements are:" + String.valueOf(Oarray));
 
        System.out.println("Arrays after copying elements are:"+ String.valueOf(Farray));  
    }  
}

Resultado:

Origional Array Elements are:ILoveMyCountry
Arraya after copying elements are:ILoveMyCountry

Aqui,

  • src_array: array de origem do qual os itens são copiados.
  • src_Pos: a localização dentro de array de origem é o ponto em que a cópia começará.
  • dest_array: a matriz para a qual está o destino em que os elementos serão copiados.
  • dest_Pos: posição inicial na matriz de destino dos itens a copiar.
  • length: comprimento do array a ser copiado.

Artigo relacionado - Java Array

  • Como concatenar duas arraias em Java
  • Como converter Byte Array em Hex String em Java
  • Remover duplicatas do array em Java
  • Adicionar objetos a uma matriz em Java
  • A função push() em Java