Wie erstelle ich ein generisches Array in Java?

Aufgrund der Implementierung von Java-Generika können Sie keinen Code wie diesen haben:

public class GenSet<E> {
    private E a[];

    public GenSet() {
        a = new E[INITIAL_ARRAY_LENGTH]; // error: generic array creation
    }
}

Wie kann ich dies unter Wahrung der Typensicherheit implementieren?

Ich habe in den Java-Foren eine Lösung gesehen, die so aussieht:

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

Aber ich verstehe wirklich nicht, was los ist.

Ich muss im Gegenzug eine Frage stellen: Ist Ihr GenSet"markiert" oder "nicht markiert"? Was bedeutet das?

• Aktiviert : starkes Tippen . GenSetweiß explizit, welchen Objekttyp es enthält (dh sein Konstruktor wurde explizit mit einem Class<E>Argument aufgerufen , und Methoden lösen eine Ausnahme aus, wenn ihnen Argumente übergeben werden, die nicht vom Typ sind E. Siehe Collections.checkedCollection.

  -> in diesem Fall sollten Sie schreiben:

  public class GenSet<E> {
  
      private E[] a;
  
      public GenSet(Class<E> c, int s) {
          // Use Array native method to create array
          // of a type only known at run time
          @SuppressWarnings("unchecked")
          final E[] a = (E[]) Array.newInstance(c, s);
          this.a = a;
      }
  
      E get(int i) {
          return a[i];
      }
  }

• Deaktiviert : schwache Eingabe . Für keines der als Argument übergebenen Objekte wird tatsächlich eine Typprüfung durchgeführt.

  -> in diesem Fall sollten Sie schreiben

  public class GenSet<E> {
  
      private Object[] a;
  
      public GenSet(int s) {
          a = new Object[s];
      }
  
      E get(int i) {
          @SuppressWarnings("unchecked")
          final E e = (E) a[i];
          return e;
      }
  }

  Beachten Sie, dass der Komponententyp des Arrays das Löschen des Typparameters sein sollte:

  public class GenSet<E extends Foo> { // E has an upper bound of Foo
  
      private Foo[] a; // E erases to Foo, so use Foo[]
  
      public GenSet(int s) {
          a = new Foo[s];
      }
  
      ...
  }

All dies resultiert aus einer bekannten und absichtlichen Schwäche von Generika in Java: Es wurde mithilfe von Erasure implementiert, sodass "generische" Klassen nicht wissen, mit welchem ​​Typargument sie zur Laufzeit erstellt wurden, und daher keine Typ- liefern können. Sicherheit, es sei denn, ein expliziter Mechanismus (Typprüfung) ist implementiert.

Du kannst das:

E[] arr = (E[])new Object[INITIAL_ARRAY_LENGTH];

Dies ist eine der vorgeschlagenen Möglichkeiten zum Implementieren einer generischen Sammlung in Effective Java. Punkt 26 . Keine Tippfehler, keine Notwendigkeit, das Array wiederholt umzuwandeln. Dies löst jedoch eine Warnung aus, da dies möglicherweise gefährlich ist und mit Vorsicht verwendet werden sollte. Wie in den Kommentaren ausführlich beschrieben, tarnt sich dies Object[]nun als unser E[]Typ und kann unerwartete Fehler verursachen oderClassCastException , tarnt sich bei unsicherer Verwendung verursachen.

Als Faustregel gilt, dass dieses Verhalten sicher ist, solange das Cast-Array intern verwendet wird (z. B. zum Sichern einer Datenstruktur) und nicht zurückgegeben oder dem Client-Code ausgesetzt wird. Wenn Sie ein Array eines generischen Typs an einen anderen Code zurückgeben müssen, ist die von ArrayIhnen erwähnte Reflektionsklasse der richtige Weg.

Erwähnenswert ist, dass Sie, wo immer möglich, viel glücklicher mit Lists als mit Arrays arbeiten, wenn Sie Generika verwenden. Sicherlich haben Sie manchmal keine Wahl, aber die Verwendung des Sammlungsframeworks ist weitaus robuster.

So verwenden Sie Generika, um ein Array mit genau dem Typ zu erhalten, nach dem Sie suchen, während die Typensicherheit erhalten bleibt (im Gegensatz zu den anderen Antworten, die Ihnen entweder ein ObjectArray zurückgeben oder beim Kompilieren zu Warnungen führen):

import java.lang.reflect.Array;  

public class GenSet<E> {  
    private E[] a;  

    public GenSet(Class<E[]> clazz, int length) {  
        a = clazz.cast(Array.newInstance(clazz.getComponentType(), length));  
    }  

    public static void main(String[] args) {  
        GenSet<String> foo = new GenSet<String>(String[].class, 1);  
        String[] bar = foo.a;  
        foo.a[0] = "xyzzy";  
        String baz = foo.a[0];  
    }  
}

Dies wird ohne Warnungen kompiliert, und wie Sie in sehen können main, können Sie für jeden Typ, für den Sie eine Instanz GenSetals deklarieren a, einem Array dieses Typs zuweisen und ein Element aus zuweisena zu einer Variable dieses Typs, dass das Array bedeutet und die Werte im Array sind vom richtigen Typ.

Es funktioniert mit Klassenliteralen als Laufzeit-Token, wie in den Java-Tutorials beschrieben . Klassenliterale werden vom Compiler als Instanzen von behandelt java.lang.Class. Um eine zu verwenden, folgen Sie einfach dem Namen einer Klasse mit .class. So String.classwirkt wie ein ClassObjekt der Klasse darstellt String. Dies funktioniert auch für Schnittstellen, Aufzählungen, beliebige dimensionale Arrays (z. B. String[].class) , Grundelemente (z. B. int.class) und das Schlüsselwort void(dh void.class).

Classselbst ist generisch (deklariert als Class<T>, wobei Tfür den Typ steht, den das ClassObjekt darstellt), was bedeutet, dass der Typ von String.classistClass<String> .

Wenn Sie also den Konstruktor für aufrufen GenSet, übergeben Sie ein Klassenliteral für das erste Argument, das ein Array des GenSetdeklarierten Typs der Instanz darstellt (z. B. String[].classfürGenSet<String> . ). Beachten Sie, dass Sie kein Array von Grundelementen abrufen können, da Grundelemente nicht für Typvariablen verwendet werden können.

Innerhalb des Konstruktors gibt der Aufruf der Methode castdas übergebene ObjectArgument an die Klasse zurück, die durch das ClassObjekt dargestellt wird, für das die Methode aufgerufen wurde. Das Aufrufen der statischen Methode newInstancein java.lang.reflect.Arraygibt als ObjectArray den Typ zurück, der durch das Classals erstes Argument übergebene Objekt und die durch das intals zweites Argument übergebene Länge angegebene Länge dargestellt wird . Der Aufruf der Methode getComponentTypeGibt ein ClassObjekt den Komponententyp des Arrays von dem dargestellten darstellt ClassObjekt , auf dem das Verfahren aufgerufen wurde (zB String.classfür die String[].class, nullwenn dieClass Objekt nicht ein Array darstellt).

Dieser letzte Satz ist nicht ganz richtig. Beim Aufrufen wird String[].class.getComponentType()ein ClassObjekt zurückgegeben, das die Klasse darstellt String, sein Typ jedoch Class<?>nicht Class<String>. Aus diesem Grund können Sie Folgendes nicht ausführen.

String foo = String[].class.getComponentType().cast("bar"); // won't compile

Gleiches gilt für jede Methode Class, die ein ClassObjekt zurückgibt .

In Bezug auf Joachim Sauers Kommentar zu dieser Antwort (ich habe nicht genug Ruf, um sie selbst zu kommentieren) führt das Beispiel, in dem die Besetzung verwendet T[]wird, zu einer Warnung, da der Compiler in diesem Fall keine Typensicherheit garantieren kann.

Bearbeiten Sie die Kommentare von Ingo:

public static <T> T[] newArray(Class<T[]> type, int size) {
   return type.cast(Array.newInstance(type.getComponentType(), size));
}

Dies ist die einzige Antwort, die typsicher ist

E[] a;

a = newArray(size);

@SafeVarargs
static <E> E[] newArray(int length, E... array)
{
    return Arrays.copyOf(array, length);
}

Um auf weitere Dimensionen zu erweitern, fügen Sie einfach []'s und Dimensionsparameter hinzu newInstance()( Tist ein Typparameter, clsist ein Class<T>, d1bis d5sind ganze Zahlen):

T[] array = (T[])Array.newInstance(cls, d1);
T[][] array = (T[][])Array.newInstance(cls, d1, d2);
T[][][] array = (T[][][])Array.newInstance(cls, d1, d2, d3);
T[][][][] array = (T[][][][])Array.newInstance(cls, d1, d2, d3, d4);
T[][][][][] array = (T[][][][][])Array.newInstance(cls, d1, d2, d3, d4, d5);

Siehe Array.newInstance()für Details.

In Java 8 können wir eine Art generische Array-Erstellung mit einem Lambda oder einer Methodenreferenz durchführen. Dies ähnelt dem Reflexionsansatz (der a passiert Class), aber hier verwenden wir keine Reflexion.

@FunctionalInterface
interface ArraySupplier<E> {
    E[] get(int length);
}

class GenericSet<E> {
    private final ArraySupplier<E> supplier;
    private E[] array;

    GenericSet(ArraySupplier<E> supplier) {
        this.supplier = supplier;
        this.array    = supplier.get(10);
    }

    public static void main(String[] args) {
        GenericSet<String> ofString =
            new GenericSet<>(String[]::new);
        GenericSet<Double> ofDouble =
            new GenericSet<>(Double[]::new);
    }
}

Dies wird beispielsweise von verwendet <A> A[] Stream.toArray(IntFunction<A[]>).

Dies könnte auch vor Java 8 mit anonymen Klassen erfolgen, ist jedoch umständlicher.

Dies wird in Kapitel 5 (Generika) von Effective Java, 2. Ausgabe , Punkt 25 behandelt. Ziehen Sie Listen Arrays vor

Ihr Code funktioniert, generiert jedoch eine ungeprüfte Warnung (die Sie mit der folgenden Anmerkung unterdrücken können:

@SuppressWarnings({"unchecked"})

Es wäre jedoch wahrscheinlich besser, eine Liste anstelle eines Arrays zu verwenden.

Es gibt eine interessante Diskussion über diesen Fehler / diese Funktion auf der OpenJDK-Projektseite .

Sie müssen das Class-Argument nicht an den Konstruktor übergeben. Versuche dies.

public class GenSet<T> {
    private final T[] array;
    @SuppressWarnings("unchecked")
    public GenSet(int capacity, T... dummy) {
        if (dummy.length > 0)
            throw new IllegalArgumentException(
              "Do not provide values for dummy argument.");
        Class<?> c = dummy.getClass().getComponentType();
        array = (T[])Array.newInstance(c, capacity);
    }
    @Override
    public String toString() {
        return "GenSet of " + array.getClass().getComponentType().getName()
            + "[" + array.length + "]";
    }
}

und

GenSet<Integer> intSet = new GenSet<>(3);
System.out.println(intSet);
System.out.println(new GenSet<String>(2));

Ergebnis:

GenSet of java.lang.Integer[3]
GenSet of java.lang.String[2]

Java-Generika überprüfen Typen zur Kompilierungszeit und fügen entsprechende Casts ein, löschen jedoch die Typen in den kompilierten Dateien. Dies macht generische Bibliotheken für Code verwendbar, der Generika nicht versteht (was eine bewusste Entwurfsentscheidung war), was jedoch bedeutet, dass Sie normalerweise nicht herausfinden können, um welchen Typ es sich zur Laufzeit handelt.

Der öffentliche Stack(Class<T> clazz,int capacity)Konstruktor erfordert , dass Sie ein Class - Objekt zur Laufzeit übergeben, die Mittel Klasseninformation ist zum Laufzeit - Code zur Verfügung , die es braucht. Und derClass<T> Formular bedeutet, dass der Compiler prüft, ob das von Ihnen übergebene Klassenobjekt genau das Klassenobjekt für Typ T ist. Keine Unterklasse von T, keine Oberklasse von T, sondern genau T.

Dies bedeutet dann, dass Sie in Ihrem Konstruktor ein Array-Objekt des entsprechenden Typs erstellen können. Dies bedeutet, dass der Typ der Objekte, die Sie in Ihrer Sammlung speichern, an dem Punkt überprüft wird, an dem sie der Sammlung hinzugefügt werden.

Hallo, obwohl der Thread tot ist, möchte ich Ihre Aufmerksamkeit darauf lenken:

Generics wird zur Typprüfung während der Kompilierungszeit verwendet:

• Daher besteht der Zweck darin, zu überprüfen, ob das, was hereinkommt, das ist, was Sie brauchen.
• Was Sie zurückgeben, ist das, was der Verbraucher braucht.
• Überprüfen Sie dies:

Machen Sie sich keine Sorgen über das Schreiben von Typwarnungen, wenn Sie eine generische Klasse schreiben. Sorgen Sie sich, wenn Sie es verwenden.

Was ist mit dieser Lösung?

@SafeVarargs
public static <T> T[] toGenericArray(T ... elems) {
    return elems;
}

Es funktioniert und sieht zu einfach aus, um wahr zu sein. Gibt es einen Nachteil?

Schauen Sie sich auch diesen Code an:

public static <T> T[] toArray(final List<T> obj) {
    if (obj == null || obj.isEmpty()) {
        return null;
    }
    final T t = obj.get(0);
    final T[] res = (T[]) Array.newInstance(t.getClass(), obj.size());
    for (int i = 0; i < obj.size(); i++) {
        res[i] = obj.get(i);
    }
    return res;
}

Es konvertiert eine Liste aller Arten von Objekten in ein Array desselben Typs.

Ich habe einen schnellen und einfachen Weg gefunden, der für mich funktioniert. Beachten Sie, dass ich dies nur unter Java JDK 8 verwendet habe. Ich weiß nicht, ob es mit früheren Versionen funktioniert.

Obwohl wir ein generisches Array eines bestimmten Typparameters nicht instanziieren können, können wir ein bereits erstelltes Array an einen generischen Klassenkonstruktor übergeben.

class GenArray <T> {
    private T theArray[]; // reference array

    // ...

    GenArray(T[] arr) {
        theArray = arr;
    }

    // Do whatever with the array...
}

Jetzt können wir das Array hauptsächlich so erstellen:

class GenArrayDemo {
    public static void main(String[] args) {
        int size = 10; // array size
        // Here we can instantiate the array of the type we want, say Character (no primitive types allowed in generics)
        Character[] ar = new Character[size];

        GenArray<Character> = new Character<>(ar); // create the generic Array

        // ...

    }
}

Für mehr Flexibilität mit Ihren Arrays können Sie eine verknüpfte Liste verwenden, z. die ArrayList und andere Methoden in der Java.util.ArrayList-Klasse.

Das Beispiel verwendet Java Reflection, um ein Array zu erstellen. Dies wird im Allgemeinen nicht empfohlen, da es nicht typsicher ist. Verwenden Sie stattdessen einfach eine interne Liste und vermeiden Sie das Array überhaupt.

Übergeben einer Werteliste ...

public <T> T[] array(T... values) {
    return values;
}

Ich habe dieses Code-Snippet erstellt, um eine Klasse, die für ein einfaches automatisiertes Testdienstprogramm übergeben wird, reflektierend zu instanziieren.

Object attributeValue = null;
try {
    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }
    else if(!clazz.isInterface()){
        attributeValue = BeanUtils.instantiateClass(clazz);
    }
} catch (Exception e) {
    logger.debug("Cannot instanciate \"{}\"", new Object[]{clazz});
}

Beachten Sie dieses Segment:

    if(clazz.isArray()){
        Class<?> arrayType = clazz.getComponentType();
        attributeValue = Array.newInstance(arrayType, 0);
    }

für Array-Initiierung, wobei Array.newInstance (Array-Klasse, Array-Größe) . Die Klasse kann sowohl primitiv (int.class) als auch objekt (Integer.class) sein.

BeanUtils ist Teil des Frühlings.

Eine einfachere Möglichkeit besteht darin, ein Array von Objekten zu erstellen und es wie im folgenden Beispiel in den gewünschten Typ umzuwandeln:

T[] array = (T[])new Object[SIZE];

Dabei SIZEhandelt es sich um eine Konstante und Teine Typkennung

Die von anderen Leuten vorgeschlagene Zwangsbesetzung hat bei mir nicht funktioniert, mit Ausnahme des illegalen Castings.

Diese implizite Besetzung funktionierte jedoch einwandfrei:

Item<K>[] array = new Item[SIZE];

Dabei ist Item eine von mir definierte Klasse, die das Mitglied enthält:

private K value;

Auf diese Weise erhalten Sie ein Array vom Typ K (wenn das Element nur den Wert hat) oder einen beliebigen generischen Typ, den Sie in der Klasse Element definieren möchten.

Niemand sonst hat die Frage beantwortet, was in dem von Ihnen geposteten Beispiel vor sich geht.

import java.lang.reflect.Array;

class Stack<T> {
    public Stack(Class<T> clazz, int capacity) {
        array = (T[])Array.newInstance(clazz, capacity);
    }

    private final T[] array;
}

Wie andere gesagt haben, werden Generika während der Kompilierung "gelöscht". Zur Laufzeit weiß eine Instanz eines Generikums nicht, welchen Komponententyp sie hat. Der Grund dafür ist historisch. Sun wollte Generika hinzufügen, ohne die vorhandene Schnittstelle (sowohl Quelle als auch Binärdatei) zu beschädigen.

Arrays auf der anderen Seite do ihren Komponententyp zur Laufzeit kennen.

In diesem Beispiel wird das Problem umgangen, indem der Code, der den Konstruktor aufruft (der den Typ kennt), einen Parameter übergibt, der der Klasse den erforderlichen Typ mitteilt.

Die Anwendung würde also die Klasse mit so etwas wie konstruieren

Stack<foo> = new Stack<foo>(foo.class,50)

und der Konstruktor weiß jetzt (zur Laufzeit), was der Komponententyp ist, und kann diese Informationen verwenden, um das Array über die Reflection-API zu erstellen.

Array.newInstance(clazz, capacity);

Schließlich haben wir eine Typumwandlung, da der Compiler nicht wissen kann, dass das von zurückgegebene Array Array#newInstance()der richtige Typ ist (obwohl wir es wissen).

Dieser Stil ist etwas hässlich, kann aber manchmal die am wenigsten schlechte Lösung für die Erstellung generischer Typen sein, die ihren Komponententyp zur Laufzeit aus irgendeinem Grund kennen müssen (Erstellen von Arrays oder Erstellen von Instanzen ihres Komponententyps usw.).

Ich habe eine Art Lösung für dieses Problem gefunden.

Die folgende Zeile löst einen generischen Fehler bei der Array-Erstellung aus

List<Person>[] personLists=new ArrayList<Person>()[10];

Wenn ich jedoch List<Person>in einer separaten Klasse kapsle, funktioniert es.

import java.util.ArrayList;
import java.util.List;


public class PersonList {

    List<Person> people;

    public PersonList()
    {
        people=new ArrayList<Person>();
    }
}

Sie können Personen in der Klasse PersonList durch einen Getter aussetzen. Die folgende Zeile gibt Ihnen ein Array mit einemList<Person> in jedem Element ein enthält. Mit anderen Worten Array von List<Person>.

PersonList[] personLists=new PersonList[10];

Ich brauchte so etwas in einem Code, an dem ich arbeitete, und das habe ich getan, damit es funktioniert. Bisher keine Probleme.

Sie können ein Objektarray erstellen und es überall in E umwandeln. Ja, es ist nicht sehr sauber, aber es sollte zumindest funktionieren.

Versuche dies.

private int m = 0;
private int n = 0;
private Element<T>[][] elements = null;

public MatrixData(int m, int n)
{
    this.m = m;
    this.n = n;

    this.elements = new Element[m][n];
    for (int i = 0; i < m; i++)
    {
        for (int j = 0; j < n; j++)
        {
            this.elements[i][j] = new Element<T>();
        }
    }
}

Eine einfache, wenn auch unübersichtliche Problemumgehung besteht darin, eine zweite "Inhaber" -Klasse in Ihrer Hauptklasse zu verschachteln und sie zum Speichern Ihrer Daten zu verwenden.

public class Whatever<Thing>{
    private class Holder<OtherThing>{
        OtherThing thing;
    }
    public Holder<Thing>[] arrayOfHolders = new Holder<Thing>[10]
}

Vielleicht ohne Bezug zu dieser Frage, aber während ich den " generic array creation" Fehler für die Verwendung bekam

Tuple<Long,String>[] tupleArray = new Tuple<Long,String>[10];

Ich finde die folgenden Arbeiten heraus (und habe für mich gearbeitet) mit @SuppressWarnings({"unchecked"}):

 Tuple<Long, String>[] tupleArray = new Tuple[10];

Ich frage mich, ob dieser Code ein effektives generisches Array erstellen würde.

public T [] createArray(int desiredSize){
    ArrayList<T> builder = new ArrayList<T>();
    for(int x=0;x<desiredSize;x++){
        builder.add(null);
    }
    return builder.toArray(zeroArray());
}

//zeroArray should, in theory, create a zero-sized array of T
//when it is not given any parameters.

private T [] zeroArray(T... i){
    return i;
}

Bearbeiten: Vielleicht besteht eine alternative Möglichkeit zum Erstellen eines solchen Arrays, wenn die von Ihnen gewünschte Größe bekannt und klein wäre, darin, einfach die erforderliche Anzahl von "Nullen" in den Befehl zeroArray einzugeben?

Dies ist jedoch offensichtlich nicht so vielseitig wie die Verwendung des createArray-Codes.

Sie könnten eine Besetzung verwenden:

public class GenSet<Item> {
    private Item[] a;

    public GenSet(int s) {
        a = (Item[]) new Object[s];
    }
}

Ich habe tatsächlich eine ziemlich einzigartige Lösung gefunden, um die Unfähigkeit zu umgehen, ein generisches Array zu initiieren. Was Sie tun müssen, ist eine Klasse zu erstellen, die die generische Variable T wie folgt aufnimmt:

class GenericInvoker <T> {
    T variable;
    public GenericInvoker(T variable){
        this.variable = variable;
    }
}

und dann in Ihrer Array-Klasse einfach so anfangen:

GenericInvoker<T>[] array;
public MyArray(){
    array = new GenericInvoker[];
}

Das Starten von a new Generic Invoker[]führt zu einem Problem mit dem Kontrollkästchen "Nicht aktiviert", es sollten jedoch keine Probleme auftreten.

Um aus dem Array zu gelangen, sollten Sie das Array [i] .variable wie folgt aufrufen:

public T get(int index){
    return array[index].variable;
}

Der Rest, z. B. die Größenänderung des Arrays, kann mit Arrays.copyOf () wie folgt ausgeführt werden:

public void resize(int newSize){
    array = Arrays.copyOf(array, newSize);
}

Und die Add-Funktion kann folgendermaßen hinzugefügt werden:

public boolean add(T element){
    // the variable size below is equal to how many times the add function has been called 
    // and is used to keep track of where to put the next variable in the array
    arrays[size] = new GenericInvoker(element);
    size++;
}

Laut vnportnoy die Syntax

GenSet<Integer> intSet[] = new GenSet[3];

Erstellt ein Array von Nullreferenzen, die als gefüllt werden sollen

for (int i = 0; i < 3; i++)
{
   intSet[i] = new GenSet<Integer>();
}

Das ist typsicher.

private E a[];
private int size;

public GenSet(int elem)
{
    size = elem;
    a = (E[]) new E[size];
}

Die generische Array-Erstellung ist in Java nicht zulässig, aber Sie können dies wie folgt tun

class Stack<T> {
private final T[] array;
public Stack(int capacity) {
    array = (T[]) new Object[capacity];
 }
}