Arrays copyOf en Java con ejemplos✅
Arrays copyOf en Java
Con el package java.util.Arrays podemos acceder a varios métodos, entre ellos copyOf() este método nos permite copiar un arreglo y darle nuevos espacios vacíos con el valor por defecto del tipo de dato que se haya creado.Supongamos un ejemplo de un arreglo de números enteros, que llenamos aleatoriamente, una vez está lleno el arreglo hacemos uso del método para que tengamos el mismo arreglo conservando los valores pero ahora con más espacios disponibles.
Para usar el método Arrays.copyOf(arreglo[ ], nuevoTamaño); arreglo hace referencia al arreglo que tenemos creado y nuevoTamaño va a ser la nueva dimensión que tomará arreglo.
Arrays.copyOf en Java: Copia de matrices fácil y eficiente
En Java, las matrices (arrays) son una estructura de datos
fundamental que se utiliza para almacenar y manipular conjuntos de valores del
mismo tipo. A menudo, necesitamos copiar una matriz a otra matriz para realizar
operaciones adicionales sin modificar la matriz original. La clase Arrays de
Java proporciona el método copyOf para copiar una matriz de manera fácil y
eficiente.
El método Arrays.copyOf es una sobrecarga de
System.arraycopy que se utiliza para copiar una matriz en una nueva matriz del
mismo tipo y tamaño o una nueva matriz del tipo y tamaño especificado. Este
método toma dos argumentos: la matriz original y la longitud de la nueva
matriz.
Veamos un ejemplo de cómo se utiliza este método para copiar una matriz de enteros:
Ejemplo usando copyOf en java
int[] originalArray = {1, 2, 3, 4, 5}; int[] newArray = Arrays.copyOf(originalArray, originalArray.length);
En este ejemplo, la matriz original originalArray se copia en una nueva matriz llamada newArray. La nueva matriz tiene la misma longitud que la matriz original, por lo que originalArray.length se utiliza como el segundo argumento.
Ejemplo
import java.util.Arrays; public class Probando { //creamos el arreglo inicialmente de 5 static int arreglo [] = new int[5]; public static void main(String[] args) { for (int i = 0; i < arreglo.length; i++) { /*vamos a crear numeros aleatorios*/ /*para llenar el arreglo*/ arreglo[i] = (int) (Math.random() * 10 + 2); } /*podemos imprimir el arreglo con Arrays.toString*/ System.out.println(Arrays.toString(arreglo)); /*hasta este punto tendriamos el arreglo lleno*/ /*entonces vamos a usar copyOf*/ arreglo =Arrays.copyOf(arreglo, arreglo.length*2); /*y volvemos a imprimir*/ System.out.println(Arrays.toString(arreglo)); } }
Salida
[5, 9, 4, 8, 4] [5, 9, 4, 8, 4, 0, 0, 0, 0, 0]
Tenemos que tener algo muy claro, la cantidad de elementos no es lo mismo que la longitud del arreglo, por ejemplo, la cantidad de elementos es 5 correspondientes a 5, 9, 4, 8, 4 pero los otros 5 índices están vacíos 0, 0, 0, 0, 0 por lo que dentro de un arreglo de 10 índices, solo tenemos 5 elementos en realidad.
En este caso lo hemos hecho con un arreglo static, también podemos colocar condiciones, como por ejemplo: Si el arreglo se llena entonces le damos más espacios según sea el caso, pero todo esto se puede hacer de manera automática si nosotros le indicamos.
Como pueden observar también usamos otro método de la clase Arrays el cual fue Arrays.toString(arreglo) para imprimir el arreglo sin necesidad de usar un ciclo for.
¿Cómo usar Arrays.copyOf con objetos?
Imaginemos que no existen las estructuras dinámicas tales como LinkedList<> o ArrayList<> en este caso ¿Cómo podríamos hacer que un arreglo sea dinámico?, con Arrays.copyOf podemos tratar de imitar el funcionamiento.
Vamos a crear una Clase llamada CuentaBancaria con los siguientes atributos y métodos.
public class CuentaBancaria {
private long codigo;
private String titular;
private int cantidad;
public CuentaBancaria(long codigo, String titular, int cantidad) {
this.codigo = codigo;
this.titular = titular;
this.cantidad = cantidad;
}
public CuentaBancaria(long codigo) {
this.codigo = codigo;
this.titular = "persona "+codigo;
this.cantidad=0;
}
public long getCodigo() {
return codigo;
}
public void setCodigo(long codigo) {
this.codigo = codigo;
}
public String getTitular() {
return titular;
}
public void setTitular(String titular) {
this.titular = titular;
}
public int getCantidad() {
return cantidad;
}
public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}
@Override
public String toString() {
return "CuentaBancaria{" + "codigo=" + codigo + ", titular=" + titular + ", cantidad=" + cantidad + '}';
}
}
Ahora en el Main vamos a crear un arreglo y una variable estática, el arreglo inicia solo con 2 espacios:
import java.util.Arrays;
import java.util.Scanner;
public class NewMain {
static CuentaBancaria listadoCuentas[] = new CuentaBancaria[2];
static int pos = 0;
public static void main(String[] args) {
boolean verificacion;
CuentaBancaria nueva;
int opcion;
int opcion2;
long codigo;
String titular;
int cantidad;
Scanner en = new Scanner(System.in);
do {
System.out.println("\n\t Banco");
System.out.println("1. Crear Cuenta");
System.out.println("2. Ingresar dinero");
System.out.println("3. Retirar dinero");
System.out.println("4. Mostrar saldo");
System.out.println("5. Mostrar todas la cuentas");
System.out.println("6. Salir");
System.out.print("Ingrese un a opcion: ");
opcion = en.nextInt();
switch (opcion) {
case 1:
if (listadoCuentas.length == pos) {
listadoCuentas = Arrays.copyOf(listadoCuentas, listadoCuentas.length * 2);
}
System.out.println("Ingrese los datos");
System.out.println("Codigo será "+pos);
codigo = pos;
System.out.print("Nombre persona: ");
titular = en.next();
System.out.print("Saldo Inicial: ");
cantidad = en.nextInt();
nueva = new CuentaBancaria(codigo, titular, cantidad);
listadoCuentas[pos] = nueva;
pos++;
break;
case 2:
System.out.println("*****************************");
System.out.println("\n\tIngresar dinero");
System.out.print("ingrese el codigo de la cuenta: ");
codigo = en.nextLong();
//nueva = b1.BuscarCuenta(codigo);
if (codigo < pos) {
nueva = listadoCuentas[(int) codigo];
if (nueva != null) {
System.out.println("Cantidad a ingresar a la cuenta");
cantidad = en.nextInt();
verificacion = nueva.ingresar(cantidad);
System.out.println(verificacion ? "\nSe ha ingresado correctamente" : "\nNo ha sido posible");
} else {
System.out.println("Cuenta no encontrada");
}
} else {
System.out.println("por fuera del rango");
}
break;
case 3:
System.out.println("*****************************");
System.out.println("\n\tRetirar dinero");
System.out.print("ingrese el codigo de la cuenta: ");
codigo = en.nextLong();
//nueva = b1.BuscarCuenta(codigo);
if (codigo < pos) {
nueva = listadoCuentas[(int) codigo];
if (nueva != null) {
System.out.println("Cantidad a retirar");
cantidad = en.nextInt();
verificacion = nueva.retirar(cantidad);
System.out.println(verificacion ? "\nSe ha ingresado correctamente" : "\nNo ha sido posible");
} else {
System.out.println("Cuenta no encontrada");
}
} else {
System.out.println("por fuera del rango");
}
break;
case 4:
System.out.println("*****************************");
System.out.println("\n\tConsultar saldo");
System.out.print("ingrese el codigo de la cuenta: ");
codigo = en.nextLong();
if (codigo < pos) {
nueva = listadoCuentas[(int) codigo];
if (nueva != null) {
System.out.println("\n Su saldo es: " + nueva.getCantidad());
} else {
System.out.println("Cuenta no encontrada");
}
}
//nueva = b1.BuscarCuenta(codigo);
break;
case 5:
System.out.println("*****************************");
//b1.mostrarCuentas();
for (CuentaBancaria cuenta : listadoCuentas) {
if (cuenta != null) {
System.out.println(cuenta.toString());
}
}
break;
case 6:
System.out.println("*****************************");
System.out.println("Ha salido");
break;
default:
System.out.println("Opcion no valida");
}
} while (opcion != 6);
}
}
Si ejecutamos esto y creamos 2 cuentas, automáticamente va a generar el doble de espacios, de esta manera vamos a crear las cuentas que deseemos y no se va a llenar el arreglo.
arrays class in java,arrays,java arrays,array,arrays copy java,copy array,copy array using arrays copyof method in java,java array,arrays java copy array,arrays java,arrays in java,2d arrays in java,array copying,clase arrays java,arrays copy,how to copy an array,java 2d array,java arrays copying,java copy between arrays,copy array java,array copy java 7,copy array java 5,copying arrays,array copy java api,copy array java 1.5,array copy
