Cómo agregar un nuevo elemento a una matriz en Java

Oh, arreglos de Java. Son objeto de intenso amor y odio de cientos de desarrolladores de software principiantes. Agregar elementos a una matriz que ya fue inicializada es imposible, dijeron... En realidad, es posible, pero no en un sentido clásico... y no es muy conveniente. Agregar nuevos elementos a una matriz que ya se inicializó es una especie de truco. Sin embargo, estos trucos pueden ser útiles en una entrevista... ya veces en el trabajo de un programador. Para asegurarnos de que disfrute usando el tipo de datos y sepa cómo hacerlo de manera eficiente, escribimos una guía sobre cómo agregar un nuevo elemento a una matriz de Java. Además de revisar cuidadosamente la teoría y las muestras de código, asegúrese de revisar y completar los problemas de práctica que se muestran en la publicación.

¿Qué es una matriz en Java?

Recordemos qué es un Array y cómo crearlo en Java. Si lo recuerda, no dude en pasar directamente al siguiente subtítulo "5 formas de agregar nuevos elementos a matrices Java". La documentación oficial de Java de Oracle dice que las matrices son una serie de valores que pertenecen al mismo tipo de datos. Un conjunto de enteros es un ejemplo perfecto de una matriz en Java . Todos los valores que defina tienen una posición específica dentro de la matriz denominada índice . Estas son las formas de declarar e inicializar matrices:

int[] myArray = new int[10];
int[] myArray1 = {1, 0, 3, 17, 5, 6, 7, 8, 9, 10}

En el primer caso, definimos una matriz myArray e hicimos que Java asignara espacio para una matriz de 10 elementos, en el segundo myArray1 , ingresamos inmediatamente 10 valores en ella. En cualquier caso, el elemento 11 no puede insertarse simplemente en la matriz. Para realizar operaciones con matrices, los desarrolladores manipulan los índices de valores que contiene una matriz. ¿Qué debemos hacer? Echemos un vistazo a las formas más comunes de agregar a la matriz.

5 formas de agregar nuevos elementos a los arreglos de Java

Bueno, aquí nuestros trucos para hacer que lo inmutable parezca mutable.

• Convertir una matriz en una lista
• Cree una nueva matriz con mayor capacidad y agregue un nuevo elemento a la matriz
• Implementando System.arraycopy()
• Copiar arreglos usando Apache Commons
• Aplicando el método ArrayCopyOf()

Echemos un vistazo más de cerca a estas formas de agregar un elemento a una matriz.

1. Convertir una matriz en una lista

Dado que no podemos agregar un nuevo elemento a una matriz directamente, lo mejor que puede hacer es convertirlos en listas, agregar nuevos elementos y volver a convertir los valores en matrices. La primera forma de convertir una matriz en una lista es usar asList() para crear una nueva ArrayList. Una vez que el rango de valores se transforme con éxito, use ListAdd() para insertar el valor. Una vez que ya no necesite editar una matriz, vuelva a convertirla al tipo de datos original con la ayuda del método toArray() . Con todos los métodos y conversiones, esto puede parecer confuso al principio. Echemos un vistazo al ejemplo del uso de asList() para aclarar las cosas.

// Code for adding Java arrays to a program
import java.lang.*;
import java.util.*;

class ArrayDemo{
   //Let’s add a new element to an array
   public static Integer[] addX(Integer myArray[], int x) {
       int i;
       //turn array into ArrayList using asList() method
       List arrList = new ArrayList( Arrays.asList(myArray));

       // adding a new element to the array
       arrList.add(x);

       // Transforming the ArrayList into an array
       myArray = arrList.toArray(myArray);
       return myArray;
   }
   public static void main(String[] args) {
       int i;
       //initial array
       Integer myArray[] = { 0, 1, 2, 45, 7, 5, 17};

       //print the initial array out
       System.out.println("Initial Array: "
                          + Arrays.toString(myArray));

       //element to be added
       int x = 28;

       // call the method to add x in myArray
       myArray = addX(myArray, x);

       // print the updated array out
       System.out.println("Array with " + x + " added: "
                          + Arrays.toString(myArray));
   }
}

La salida es: Entonces, en el programa hemos creado con éxito una matriz myArray de 7 valores, la completamos y la imprimimos. Entonces decidimos que diez valores no eran suficientes para nosotros. Bien, convertimos myArray en una ArrayList arrList usando el método Arrays.asList . Aquí está 28, el elemento que se agregará. Lo agregamos a ArrayList arrList y luego lo volvimos a convertir en un arreglo usando el método toArray() e imprimimos el nuevo arreglo.

2. Cree una nueva matriz con mayor capacidad

Una de las formas más comunes de agregar más elementos a una matriz es creando una matriz nueva y más grande desde cero, colocando los elementos de las anteriores y agregando elementos nuevos. Aquí hay un tutorial paso a paso del proceso:

• Cree una nueva matriz con la capacidad a+n (a: la capacidad original de la matriz, n: la cantidad de elementos que desea agregar).
• Agregue todos los elementos del rango de datos anterior al nuevo, así como los nuevos valores.
• Imprime la matriz resultante.

Intente crear una matriz de este tipo por su cuenta y compare su código con el del siguiente ejemplo:

// Java Program to add an element in an Array

import java.lang.*;
import java.util.*;

class ArrayDemo {
   //Method to add an element x into array myArray
   public static int[] addX(int myArray[], int x) {
       int i;

       // create a new array of a bigger size (+ one element)
       int newArray[] = new int[myArray.length + 1];

       // insert the elements from the old array into the new one
       for (i = 0; i < myArray.length; i++)
           newArray[i] = myArray[i];

       newArray[myArray.length] = x;
       return newArray;
   }

   public static void main(String[] args) {
       int i;

       // initial array of size 10
       int arr[]
               = {0, 1, 2, 45, 7, 5, 17};

       // print the initial array
       System.out.println("Initial Array: " + Arrays.toString(arr));

       // element to be added
       int x = 28;

       // call the addX method to add x in arr
       arr = addX(arr, x);
       // print the updated array
       System.out.println("Array with " + x + " added:" + Arrays.toString(arr));
   }
}

La salida es: Bueno, esta forma de agregar un nuevo elemento a una matriz es la más fácil.

3. Aplicar System.arrayCopy()

System.arrayCopy() es un método ampliamente utilizado para asignar una matriz más grande en el destino de una matriz de origen. Un desarrollador puede especificar la secuencia que quiere copiar a una nueva matriz en los paréntesis del método. Para ver cómo funciona el método e intentar usarlo usted mismo, eche un vistazo e intente ejecutar el siguiente ejemplo:

import java.util.Arrays;

class ArrayDemo {
   private static Integer[] addElement(Integer[] myArray, int newElement) {
       //we create a new Object here, an array of bigger capacity
       Integer[] array = new Integer[myArray.length + 1];
       System.arraycopy(myArray, 0, array, 0, myArray.length);
       array[myArray.length] = newElement;
       return array;
   }

   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}

La salida es: Aquí hemos creado una matriz myArray , la imprimimos y agregamos un nuevo elemento usando nuestro método addElement , que se basa en System.arrayCopy() .

4. Uso de Apache Commons para copiar arreglos

Usemos una forma no estándar. A saber, una biblioteca de terceros Apache Commons lang. Es parte del proyecto Apache Commons centrado en todos los aspectos de los componentes reutilizables de Java. El conocimiento sobre el proyecto no será superfluo. Apache Commons lang tiene un método add () diseñado específicamente para permitir la expansión de matrices, ahorra mucho tiempo y esfuerzo a los programadores. Vale la pena tener en cuenta que este método add() de Apache Commons se basa en llamar al método System.arraycopy() en caso de que tenga que responder a una pregunta complicada de un examen o una entrevista. Para agregar las bibliotecas a su proyecto, vaya al sitio web de Apache Commons y descargue las bibliotecas. Luego vaya a Archivo → Estructura del proyecto → Bibliotecas > + y seleccione los archivos jar descargados.

import org.apache.commons.lang3.ArrayUtils;
import java.util.Arrays;

class ArrayDemo {
   private static <T> T[] append(T[] arr, T element) {
       return ArrayUtils.add(arr, element);
   }

   public static void main(String[] args) {
       Integer[] myArray = { 0, 1, 2, 3, 4};
       System.out.println("myArray: " + Arrays.toString(myArray));

       myArray = append(myArray, 5);
       System.out.println("new Array with the number added: " + Arrays.toString(myArray));
   }
}

La salida es:

5. Implementando ArrayCopyOf()

ArrayCopyOf() es un método más para agregar un nuevo elemento a una matriz. Como Apache Commons lang add(), llama internamente a System.arraycopy() para realizar esta operación. Sin embargo, la mayoría de los desarrolladores prefieren ArrayCopyOf() ya que les permite mantener el código conciso y legible. Aquí hay un ejemplo del uso de ArrayCopyOf() para agregar nuevos elementos a una matriz:

import java.util.Arrays;
class ArrayDemo {
   private static <X> X[] addElement(X[] myArray, X element) {
       X[] array = Arrays.copyOf(myArray, myArray.length + 1);
       array[myArray.length] = element;
       return array;
   }
   public static void main(String[] args) {
       Integer[] myArray = {20, 21, 3, 4, 5, 88};
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
       myArray = addElement(myArray, 12);
       System.out.println("myArray before adding a new element: " + Arrays.toString(myArray));
   }
}

La salida es:

Conclusión

Saber cómo agregar elementos a una matriz ayuda a los desarrolladores a actualizar el código antiguo rápidamente sin sacrificar su funcionalidad y legibilidad... O simplemente para pasar la entrevista. Dado que existen diferentes formas de agregar elementos a las matrices de Java, siéntase libre de elegir el método con el que se sienta cómodo.