Clonar Arrays Java

1. Copia manual del array de Java utilizando el bucle for en Java
2. Uso de Arrays.copyOf() para clonar un array en Java
3. Uso de Arrays.copyOfRange() para clonar un array de Java
4. Uso de Object.clone() para clonar un array de Java
5. Uso de System.arraycopy() para clonar un array de Java

Las arrays de Java se pueden copiar en otra matriz de las siguientes formas.

• Uso de la asignación de variables: esta técnica tiene sus desventajas porque cualquier cambio en un elemento de array se refleja en ambos lugares.
• Cree un array del mismo tamaño y copie todos los elementos.
• Hacer uso de la técnica de clonar a el array. Los métodos de clonación crean una nueva matriz de tamaño similar.
• Hacer uso de la técnica System.arraycopy(). arraycopy es un método para copiar una parte específica de un array.

Copia manual del array de Java utilizando el bucle for en Java

Normalmente, en el momento en que queremos copiar variables como a y b, realizamos la operación de copia de la siguiente manera:

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

Producción :

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

No será efectivo cuando aplique este mismo procedimiento a las arrays.

Uso de Arrays.copyOf() para clonar un array en Java

Este método que es Arrays.copyOf() es útil para el uso interno del procedimiento System.arraycopy(). Si bien no es tan eficaz como la copia de arrays, podría duplicar una parte o una totalidad de las arrays, de forma similar al método de copia de arrays. El método copyOf() es un elemento del paquete java.util y es parte de la clase Arrays. La idea básica detrás de este método es:

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

Producción :

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

Aquí,

• original: el array que se copiará en el array recién creada.
• newLength: longitud del array copiada que se devolverá.

Por lo tanto, este método crea una copia exacta del array proporcionada como primer argumento para el tamaño especificado rellenando o truncando la longitud agregando 0 para crear la nueva matriz. Esto significa que si el tamaño del array copiada es mayor que lo que estaba originalmente en el array 0, los elementos restantes se sustituyen por s.

Uso de Arrays.copyOfRange() para clonar un array de Java

El método Arrays.copyOfRange() está especialmente diseñado para copiar partes de arrays. Similar al método toCopyOf(), el método utiliza la técnica System.arraycopy(). La idea básica detrás del procedimiento Arrays.copyOfRange() se puede describir de la siguiente manera:

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

Producción :

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

Aquí,

• original: el array de un rango que se está copiando.
• from: índice del array que se va a copiar inclusive.
• to: el Índice del Rango que se va a copiar, y exclusivo.

Uso de Object.clone() para clonar un array de Java

Las arrays Java implementan internamente una interfaz clonable, por lo que es fácil clonar arrays Java. Es posible clonar arrays unidimensionales y bidimensionales. Si copia un array unidimensional, crea una réplica extensa de los elementos del array que copia los valores.

Por otro lado, cuando copia arrays bidimensionales o multidimensionales, obtiene una pequeña copia de los elementos que se crea, es decir, se copia la única información de referencia. Este proceso de clonación se logra utilizando el método clone() ofrecido a las 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);
  }
}

Producción :

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

NArray == CArray = false

Uso de System.arraycopy() para clonar un array de Java

La clase System de Java proporciona una opción llamada ArrayCopy que le permite copiar elementos de un array a otra. El modelo más común para este método es:

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

Producción :

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

Aquí,

• src_array: matriz de origen desde la que se copian los elementos.
• src_Pos: La ubicación dentro del array de origen es el punto en el que comenzará la copia.
• dest_array: El array en el que se encuentra el destino en el que se copiarán los elementos.
• dest_Pos: Posición inicial en el array de destino de los elementos a copiar.
• length: longitud del array que se va a copiar.