Resolver error de creación de matriz genérica en Java

1. Demostración del error de creación de matriz genérica en Java
2. Posibles causas del error de creación de matriz genérica en Java
3. Posibles soluciones para erradicar el error de creación de matriz genérica en Java

Este tutorial ilustra el error de “creación de matriz genérica” a través de un ejemplo de código y destaca por qué tenemos este error al crear una matriz genérica. Esta discusión conducirá a la solución donde aprenderemos cómo crear una matriz genérica utilizando la matriz Objeto y la función reflejar.

Demostración del error de creación de matriz genérica en Java

Código de ejemplo (clase DemoGenArray.java):

import java.util.Arrays;

public class DemoGenArray<T> {
  private T[] genericArray;

  DemoGenArray(int size) {
    genericArray = new T[size]; //<----This Line Has Generic Array Creation Error
  }

  public T get(int index) {
    return (T) genericArray[index];
  }

  public void set(int index, T item) {
    genericArray[index] = item;
  }

  @Override
  public String toString() {
    return Arrays.toString(genericArray);
  }
}

En esta clase, tratamos de crear e inicializar una matriz genérica con el tamaño de matriz especificado. Además, agregamos elementos a la matriz y devolvemos los elementos individualmente desde el índice dado.

El toString() devuelve toda la matriz a la vez.

El problema es que tenemos un error de creación de matriz genérica en la línea que estamos señalando en el constructor. Exploremos las posibles causas de este error que nos ayudarán a avanzar hacia su solución.

Posibles causas del error de creación de matriz genérica en Java

Estamos tratando de crear una matriz genérica en nuestro código, lo cual es imposible en Java. Es porque Java decide conscientemente detener explícitamente el funcionamiento de estas sintaxis.

Recuerde, las matrices son covariantes (podemos asignar un subtipo a su referencia de supertipo) en Java, mientras que los genéricos no lo son.

private T[] genericArray;
genericArray = new T[size];

Las dos líneas de código anteriores son las mismas que se indican a continuación. Puedes usar cualquiera de ellos.

private T[] genericArray = new T[size];

Ocurre debido al type-erasure que implementa Java. Es un proceso llevado a cabo por el compilador de Java.

Elimina tipos parametrizados en genéricos y los asigna a tipos sin procesar en el código de bytes.

Recuerde, el código de bytes no tiene detalles sobre genéricos. Usar el tipo T estará bien en tiempo de compilación pero no tiene sentido en tiempo de ejecución.

De otras maneras, podemos eludir esta restricción que se proporciona a continuación con ejemplos de código. Aprendamos cada uno de ellos a continuación.

Posibles soluciones para erradicar el error de creación de matriz genérica en Java

Como ya sabemos, el compilador no tiene ninguna información sobre los tipos parametrizados en tiempo de ejecución. Por lo tanto, siempre que se nos requiera usar genéricos, es bueno preferir y usar el componente de lista del marco de Colecciones de Java en lugar de usar arreglos.

Sin embargo, aún podemos crear estructuras genéricas similares a matrices, pero esta solución depende de si está “marcada” o “no marcada”. Usamos la matriz Objeto si está desmarcada.

En el caso de marcado, podemos usar la función reflejar de Java. Veamos cómo funciona cada uno de ellos.

Solución 1: Utilice la matriz Objeto

Código de ejemplo (clase DemoGenArray.java):

import java.util.Arrays;

public class DemoGenArray<T> {
  private Object[] genericArray;

  DemoGenArray(int size) {
    genericArray = new Object[size];
  }

  public T get(int index) {
    return (T) genericArray[index];
  }

  public void set(int index, T item) {
    genericArray[index] = item;
  }

  @Override
  public String toString() {
    return Arrays.toString(genericArray);
  }
}

Código de ejemplo (clase GenArray.java):

public class GenArray {
  public static void main(String[] args) {
    DemoGenArray<String> strArray = new DemoGenArray(3);
    strArray.set(0, "one");
    strArray.set(1, "two");
    strArray.set(2, "three");

    DemoGenArray<Integer> intArray = new DemoGenArray(3);
    intArray.set(0, 10);
    intArray.set(1, 20);
    intArray.set(2, 30);

    DemoGenArray<Double> doubleArray = new DemoGenArray(3);
    doubleArray.set(0, 15.0);
    doubleArray.set(1, 110.0);
    doubleArray.set(2, 10.0);

    System.out.println("Integer Array: " + intArray);
    System.out.println("String Array: " + strArray);
    System.out.println("Double Array: " + doubleArray);
  }
}

Producción :

Integer Array: [10, 20, 30]
String Array: [one, two, three]
Double Array: [15.0, 110.0, 10.0]

Aquí, usamos la matriz Objeto para simular la matriz genérica porque la clase DemoGenArray está desmarcada (tipo débil). Podemos usar este enfoque si sabemos que no se realizará ninguna verificación de tipos en los objetos pasados como argumentos.

Además, usamos los métodos genéricos get() y set() para devolver el valor y establecer el valor respectivamente. El método get() utiliza una conversión explícita a T, donde T actúa como un marcador de posición para los genéricos y representa cualquier valor/elemento.

Esto funciona bien si usamos los métodos set() y get() y no permitimos que el usuario acceda directamente a la matriz Objeto. Llegando a la clase GenArray, que contiene el método main().

Aquí creamos la instancia de la clase DemoGenArray.

Pasamos el tipo requerido mientras instanciamos la clase DemoGenArray y los llenamos. Después de eso, usamos el método toString() para escribir el contenido de todas las instancias.

Solución 2: utilice la función reflejar

Código de ejemplo (clase DemoGenArray.java):

import java.lang.reflect.Array;
import java.util.Arrays;

public class DemoGenArray<T> {
  private T[] genericArray;

  DemoGenArray(Class<T> classType, int size) {
    genericArray = (T[]) Array.newInstance(classType, size);
  }

  public T get(int index) {
    return (T) genericArray[index];
  }

  public void set(int index, T item) {
    genericArray[index] = item;
  }

  @Override
  public String toString() {
    return Arrays.toString(genericArray);
  }
}

Código de ejemplo (clase GenArray.java):

public class GenArray {
  public static void main(String[] args) {
    DemoGenArray<String> strArray = new DemoGenArray(String.class, 3);
    strArray.set(0, "one");
    strArray.set(1, "two");
    strArray.set(2, "three");

    DemoGenArray<Integer> intArray = new DemoGenArray(Integer.class, 3);
    intArray.set(0, 10);
    intArray.set(1, 20);
    intArray.set(2, 30);

    DemoGenArray<Double> doubleArray = new DemoGenArray(Double.class, 3);
    doubleArray.set(0, 15.0);
    doubleArray.set(1, 110.0);
    doubleArray.set(2, 10.0);

    System.out.println("Integer Array: " + intArray);
    System.out.println("String Array: " + strArray);
    System.out.println("Double Array: " + doubleArray);
  }
}

Producción :

Integer Array: [10, 20, 30]
String Array: [one, two, three]
Double Array: [15.0, 110.0, 10.0]

Aquí, estamos usando la clase de reflexión para crear la matriz genérica cuyo tipo solo se conocerá en tiempo de ejecución. Esta solución es similar a la Solución 1 excepto por dos diferencias en la clase DemoGenArray.

Primero, tenemos un constructor en la clase DemoGenArray que acepta dos argumentos, tipo y tamaño de la matriz. En segundo lugar, inicializamos el genericArray usando el método Array.newInstance().

El método Array.newInstance() crea una nueva matriz utilizando la dimensión dada (tamaño de la matriz) y el tipo de componente.