Beheben Sie den Fehler bei der Erstellung eines generischen Arrays in Java

1. Demonstration des Fehlers generic array creation in Java
2. Mögliche Ursachen für den Fehler generic array creation in Java
3. Mögliche Lösungen zur Beseitigung des Fehlers generische Array-Erstellung in Java

Dieses Tutorial veranschaulicht den Fehler generische Array-Erstellung anhand eines Codebeispiels und zeigt auf, warum wir diesen Fehler beim Erstellen eines generischen Arrays haben. Diese Diskussion führt zu der Lösung, in der wir lernen, wie man ein generisches Array mit der Funktion Objekt Array und Reflex erstellt.

Demonstration des Fehlers generic array creation in Java

Beispielcode (Klasse 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);
  }
}

In dieser Klasse versuchen wir, ein generisches Array mit der angegebenen Array Größe zu erstellen und zu initialisieren. Außerdem fügen wir dem Array Elemente hinzu und geben die Elemente einzeln aus dem angegebenen index zurück.

toString() gibt das ganze Array auf einmal zurück.

Das Problem ist, dass wir in der Zeile, auf die wir im Konstruktor hinweisen, einen generischen Array-Erstellungsfehler haben. Lassen Sie uns die möglichen Ursachen für diesen Fehler untersuchen, die uns bei der Lösung helfen werden.

Mögliche Ursachen für den Fehler generic array creation in Java

Wir versuchen, in unserem Code ein generisches Array zu erstellen, was in Java unmöglich ist. Dies liegt daran, dass Java sich bewusst dafür entscheidet, diese Syntaxen explizit daran zu hindern, zu funktionieren.

Denken Sie daran, dass Arrays in Java kovariant sind (wir können ihrer Supertyp-Referenz einen Untertyp zuweisen), während Generika dies nicht sind.

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

Die beiden obigen Codezeilen sind die gleichen wie unten angegeben. Sie können jeden von ihnen verwenden.

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

Dies geschieht aufgrund der von Java implementierten Typlöschung. Es ist ein Prozess, der vom Java-Compiler ausgeführt wird.

Es entfernt parametrisierte Typen in Generika und ordnet sie rohen Typen im Bytecode zu.

Denken Sie daran, dass der Bytecode keine Details zu Generika enthält. Die Verwendung des Typs T ist zur Kompilierzeit in Ordnung, hat aber zur Laufzeit keine Bedeutung.

Auf andere Weise können wir diese Einschränkung umgehen, die unten mit Codebeispielen angegeben ist. Lassen Sie uns jeden von ihnen unten lernen.

Mögliche Lösungen zur Beseitigung des Fehlers generische Array-Erstellung in Java

Wie wir bereits wissen, hat der Compiler zur Laufzeit keine Informationen über parametrisierte Typen. Wann immer wir also Generika verwenden müssen, ist es gut, die Listenkomponente des Java-Frameworks Collections zu bevorzugen und zu verwenden, anstatt Arrays zu verwenden.

Wir können jedoch immer noch Array-ähnliche generische Strukturen erstellen, aber diese Lösung hängt davon ab, ob sie markiert oder ungeprüft ist. Wir verwenden das Array Object, wenn es unchecked ist.

Im Fall von checked können wir die reflect-Funktion von Java verwenden. Mal sehen, wie jeder von ihnen funktioniert.

Lösung 1: Verwenden Sie das Objekt-Array

Beispielcode (Klasse 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);
  }
}

Beispielcode (Klasse 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);
  }
}

Ausgang:

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

Hier verwenden wir das Array Object, um das generische Array zu simulieren, da die Klasse DemoGenArray ungeprüft ist (schwache Typisierung). Wir können diesen Ansatz verwenden, wenn wir wissen, dass keine Typprüfung für Objekte durchgeführt wird, die als Argumente übergeben werden.

Außerdem verwenden wir generische get()- und set()-Methoden, um den Wert zurückzugeben bzw. den Wert zu setzen. Die Methode get() verwendet eine explizite Umwandlung in T, wobei T wie ein Platzhalter für die Generika fungiert und einen beliebigen Wert/ein beliebiges Element darstellt.

Dies funktioniert gut, wenn wir die Methoden set() und get() verwenden und den Benutzer nicht direkt auf das Array Object zugreifen lassen. Kommen wir zur Klasse GenArray, die die Methode main() enthält.

Hier erstellen wir die Instanz der Klasse DemoGenArray.

Wir übergeben den erforderlichen Typ, während wir die Klasse DemoGenArray instanziieren und füllen. Danach verwenden wir die Methode toString(), um die Inhalte aller Instanzen zu schreiben.

Lösung 2: Verwenden Sie die Funktion Reflexion

Beispielcode (Klasse 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);
  }
}

Beispielcode (Klasse 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);
  }
}

Ausgang:

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

Hier verwenden wir die Reflexionsklasse, um das generische Array zu erstellen, dessen Typ nur zur Laufzeit bekannt ist. Diese Lösung ähnelt Lösung 1 mit Ausnahme von zwei Unterschieden in der Klasse DemoGenArray.

Erstens haben wir einen Konstruktor in der Klasse DemoGenArray, der zwei Argumente akzeptiert, Typ und Größe des Arrays. Zweitens initialisieren wir das genericArray mit der Methode Array.newInstance().

Die Methode Array.newInstance() erstellt ein neues Array mit der angegebenen Dimension (Größe des Arrays) und dem Komponententyp.