Generische Array-Erstellung in Java
- Verwenden Sie Objekt-Arrays, um generische Arrays in Java zu erstellen
- Verwenden Sie die Reflection-Klasse, um generische Arrays in Java zu erstellen
Ein Array kann als eine Sammlung von Elementen definiert werden, die an zusammenhängenden Speicherorten gespeichert sind. Ein generisches Array ist unabhängig von jedem Datentyp und dessen Informationstyp wird zur Laufzeit ausgewertet.
Java lässt jedoch nicht zu, dass das Array generisch ist, da Arrays in Java Informationen enthalten, die mit ihren Komponenten verknüpft sind, und diese Informationen werden zur Laufzeit verwendet, um Speicher zuzuweisen.
Wir können generische Strukturen simulieren, die Array-ähnlich sind, indem wir in Java das Objektarray und die Reflexionsklassenfunktion verwenden. Wir werden diese Methoden im Folgenden besprechen.
Verwenden Sie Objekt-Arrays, um generische Arrays in Java zu erstellen
Bei diesem Ansatz wird ein Array von Typobjekten als Member verwendet. Wir verwenden die Funktionen get() und set(), um die Array-Elemente zu lesen und zu setzen.
Das folgende Programm demonstriert die Verwendung eines Objektarrays zum Erstellen eines generischen Arrays.
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);
}
}
Ausgabe:
Generic Array <Integer>: [2, 4, 6, 8, 10]
Generic Array <String>: [a, b, c, d, e]
Verwenden Sie die Reflection-Klasse, um generische Arrays in Java zu erstellen
Bei dieser Art von Ansatz wird eine Reflexionsklasse verwendet, um ein generisches Array zu erstellen, dessen Typ nur zur Laufzeit bekannt ist.
Der einzige Unterschied zwischen dem vorherigen Ansatz und diesem Ansatz besteht darin, dass die Reflexionsklasse selbst als Konstruktor verwendet wird. Danach initiiert die Reflexionsklasse ein Objektarray, indem sie die Daten explizit an die Konstruktorklasse übergibt.
Das folgende Programm demonstriert die Verwendung von Reflektion zum Erstellen eines generischen Arrays.
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);
}
}
Ausgabe:
Generic Array<Int>: [12, 13, 14, 15, 16]
Generic Array<Str>: [A, B, C, D, E]
Generisches Array kann keine Typsicherheit bieten, es sei denn, eine Typüberprüfung oder ein expliziter Mechanismus wird implementiert, da generische Klassen für den zur Laufzeit erstellten Argumenttyp unbekannt sind.
Wenn wir mithilfe von Generika ein präzises Array ohne die oben besprochene Sicherheit haben möchten, können Sie dies wie unten gezeigt tun.
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];
}
}
Dieser Code gibt zur Kompilierzeit keine Warnungen aus, und wir können sehen, dass in der Hauptklasse der Typ der deklarierten Instanz von Gen_Set dem x eines Arrays dieses Typs gleich zugewiesen werden kann, d. h. sowohl Array als auch die Werte des Arrays sind falsche Typen.