Creación de matrices genéricas en Java
- Utilice matrices de objetos para crear matrices genéricas en Java
- Utilice la clase de reflexión para crear matrices genéricas en Java
un array se puede definir como una colección de elementos almacenados en ubicaciones de memoria contiguas. un array genérica es independiente de cualquier tipo de datos y cuyo tipo de información se evalúa en tiempo de ejecución.
Sin embargo, Java no permite que el array sea genérica porque, en Java, los arrays contienen información asociada con sus componentes, y esta información en el tiempo de ejecución se usa para asignar memoria.
Podemos simular estructuras genéricas que son similares a un array utilizando objetos matriz y la característica de clase de reflexión en Java. Discutiremos estos métodos a continuación.
Utilice matrices de objetos para crear matrices genéricas en Java
En este enfoque, se utiliza un array de objetos de tipo como miembro. Usamos las funciones get() y set() para leer y configurar los elementos del array.
El siguiente programa demuestra el uso de un array de objetos para crear un array genérica.
import java.util.Arrays;
class Generic_Array<E> {
private final Object[] obj_array; // object array
public final int length;
// class constructor
public Generic_Array(int len) {
// new object array
obj_array = new Object[len];
this.len = len;
}
// get new object array(obj_array[i])
E get(int j) {
@SuppressWarnings("unchecked") final E e = (E) object_array[j];
return e;
}
// set e at new object array(obj_array[i])
void set(int j, E e) {
object_array[j] = e;
}
@Override
public String toString() {
return Arrays.toString(object_array);
}
}
class Main {
public static void main(String[] args) {
final int len = 5;
// creating an integer array
Generic_Array<Integer> int_Array = new Generic_Array(len);
System.out.print("Generic Array <Integer>:"
+ " ");
for (int i = 2; i < len; i++) int_Array.set(i, i * 2);
System.out.println(int_Array);
// creating a string array
Generic_Array<String> str_Array = new Generic_Array(len);
System.out.print("Generic Array <String>:"
+ " ");
for (int i = 0; i < len; i++) str_Array.set(i, String.valueOf((char) (i + 97)));
System.out.println(str_Array);
}
}
Producción :
Generic Array <Integer>: [2, 4, 6, 8, 10]
Generic Array <String>: [a, b, c, d, e]
Utilice la clase de reflexión para crear matrices genéricas en Java
En este tipo de enfoque, se usa una clase de reflexión para crear un array genérica cuyo tipo se conocerá solo en el tiempo de ejecución.
La única diferencia entre el enfoque anterior y este enfoque es que la clase de reflexión se usa como el propio constructor. Después de eso, la clase de reflexión inicia un array de objetos pasando explícitamente los datos a la clase constructora.
El siguiente programa demuestra el uso de la reflexión para crear un array genérica.
import java.util.Arrays;
class Generic_Array<E> {
private final E[] objArray;
public final int length;
// constructor class
public Generic_Array(Class<E> dataType, int length) {
// creatting a new array with the specified data type and length at runtime using reflection
// method.
this.objArray = (E[]) java.lang.reflect.Array.newInstance(dataType, len);
this.len = len;
}
// get element at obj_Array[i]
E get(int i) {
return obj_Array[i];
}
// assign e to obj_Array[i]
void set(int i, E e) {
obj_Array[i] = e;
}
@Override
public String toString() {
return Arrays.toString(obj_Array);
}
}
class Main {
public static void main(String[] args) {
final int len = 5;
// create array with Integer as data type
Generic_Array<Integer> int_Array = new Generic_Array(Integer.class, len);
System.out.print("Generic Array<Int>:"
+ " ");
for (int i = 2; i < len; i++) int_Array.set(i, i + 10);
System.out.println(int_Array);
// create an array with String as data type
Generic_Array<String> str_Array = new Generic_Array(String.class, len);
System.out.print("Generic Array<Str>:"
+ " ");
for (int i = 0; i < len; i++) str_Array.set(i, String.valueOf((char) (i + 65)));
System.out.println(str_Array);
}
}
Producción :
Generic Array<Int>: [12, 13, 14, 15, 16]
Generic Array<Str>: [A, B, C, D, E]
el array genérica no puede proporcionar seguridad de tipos a menos que se implemente una verificación de tipos o un mecanismo explícito, ya que las clases genéricas son desconocidas para ese tipo de argumento que crearon en tiempo de ejecución.
Si queremos tener un array precisa sin la seguridad discutida anteriormente usando genéricos, se puede hacer como se muestra a continuación.
import java.lang.reflect.Array;
public class Gen_Set<E> {
private E[] x;
public Gen_Set(Class<E[]> cla, int len) {
x = cla.cast(Array.newInstance(cla.getComponentType(), len));
}
public static void main(String[] args) {
Gen_Set<String> foo = new Gen_Set<String>(String[].class, 1);
String[] bar = foo.x;
foo.x[0] = "xyzzy";
String baz = foo.a[0];
}
}
Este código no dará advertencias en el momento de la compilación, y podemos ver que en la clase principal, el tipo de instancia de Gen_Set declarado puede asignarse igual a la x de un array de ese tipo, es decir, matriz y los valores del array son tipos incorrectos.