Come creare un array generico in Java?

A causa dell'implementazione dei generici Java, non puoi avere un codice come questo:

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

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

Come posso implementarlo mantenendo la sicurezza del tipo?

Ho visto una soluzione sui forum Java che va così:

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;
}

Ma davvero non capisco cosa stia succedendo.

Devo fare una domanda in cambio: il tuo è GenSet"controllato" o "non selezionato"? Cosa significa?

• Controllato : digitazione forte . GenSetsa esplicitamente che tipo di oggetti in esso contenuti (ad esempio il costruttore è stato esplicitamente chiamato con un Class<E>argomento, e metodi saranno un'eccezione quando sono passati gli argomenti che non sono di tipo E. Vedi Collections.checkedCollection.

  -> in tal caso, dovresti scrivere:

  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];
      }
  }

• Deselezionato : digitazione debole . Nessun controllo del tipo viene effettivamente eseguito su nessuno degli oggetti passati come argomento.

  -> in tal caso, dovresti scrivere

  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;
      }
  }

  Si noti che il tipo di componente dell'array dovrebbe essere la cancellazione del parametro type:

  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];
      }
  
      ...
  }

Tutto questo deriva da una debolezza nota e deliberata dei generici in Java: è stato implementato usando la cancellazione, quindi le classi "generiche" non conoscono con quale argomento sono stati creati in fase di esecuzione, e quindi non possono fornire sicurezza a meno che non sia implementato un meccanismo esplicito (controllo del tipo).

Puoi farlo:

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

Questo è uno dei modi suggeriti per implementare una raccolta generica in Effective Java; Articolo 26 . Nessun errore di tipo, non è necessario eseguire il cast dell'array ripetutamente. Tuttavia, questo attiva un avviso perché è potenzialmente pericoloso e deve essere usato con cautela. Come dettagliato nei commenti, questo Object[]è ora mascherato dal nostro E[]tipo e può causare errori o ClassCastExceptions imprevisti se usato in modo non sicuro.

Come regola generale, questo comportamento è sicuro finché l'array cast viene utilizzato internamente (ad esempio per supportare una struttura di dati) e non restituito o esposto al codice client. Se è necessario restituire un array di un tipo generico ad altro codice, la Arrayclasse di riflessione che si menziona è la strada giusta da percorrere.

Vale la pena ricordare che, ove possibile, ti divertirai molto di più a lavorare con Lists piuttosto che con array se usi generici. Certamente a volte non hai scelta, ma l'utilizzo del framework delle raccolte è molto più robusto.

Ecco come utilizzare generics per ottenere un array esattamente del tipo che stai cercando, preservando la sicurezza del tipo (al contrario delle altre risposte, che ti restituiranno un Objectarray o genereranno avvisi al momento della compilazione):

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];  
    }  
}

Questo si compila senza avvertimenti e, come puoi vedere main, per qualunque tipo tu dichiari un'istanza di GenSetas, puoi assegnarlo aa un array di quel tipo e puoi assegnare un elemento aa una variabile di quel tipo, il che significa che l'array e i valori nella matrice sono del tipo corretto.

Funziona usando i letterali di classe come token di tipo runtime, come discusso nei Tutorial Java . I letterali di classe vengono trattati dal compilatore come istanze di java.lang.Class. Per usarne uno, basta seguire il nome di una classe con .class. Quindi, String.classagisce come un Classoggetto che rappresenta la classe String. Questo funziona anche per interfacce, enumerazioni, array di qualsiasi dimensione (ad es. String[].class), Primitive (ad es. int.class) E la parola chiave void(ad es void.class.).

Classstesso è generico (dichiarato come Class<T>, dove Tsta per il tipo che l' Classoggetto rappresenta), nel senso che il tipo di String.classè Class<String>.

Quindi, ogni volta che si chiama il costruttore per GenSet, si passa in una classe letterale per il primo argomento che rappresenta una matrice del GenSettipo dichiarato dell'istanza (ad esempio String[].classper GenSet<String>). Nota che non sarai in grado di ottenere una matrice di primitive, poiché le primitive non possono essere utilizzate per le variabili di tipo.

All'interno del costruttore, chiamando il metodo viene castrestituito il Objectcast dell'argomento passato alla classe rappresentata Classdall'oggetto su cui è stato chiamato il metodo. La chiamata del metodo statico newInstancein java.lang.reflect.Arrayrestituisce come una Objectmatrice del tipo rappresentato Classdall'oggetto passato come primo argomento e della lunghezza specificata dal intpassato come secondo argomento. Chiamando il metodo getComponentTyperestituisce un Classoggetto che rappresenta il tipo di componenti della matrice rappresentata dalla Classoggetto su cui è stato chiamato il metodo (ad esempio String.classper String[].class, nullse l' Classoggetto non rappresenta un array).

L'ultima frase non è del tutto accurata. La chiamata String[].class.getComponentType()restituisce un Classoggetto che rappresenta la classe String, ma il suo tipo Class<?>non Class<String>è, motivo per cui non è possibile eseguire operazioni come le seguenti.

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

Lo stesso vale per ogni metodo Classche restituisce un Classoggetto.

Per quanto riguarda il commento di Joachim Sauer su questa risposta (non ho abbastanza reputazione per commentarlo da solo), l'esempio che usa il cast per T[]genererà un avviso perché il compilatore non può garantire la sicurezza del tipo in quel caso.

Modifica in merito ai commenti di Ingo:

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

Questa è l'unica risposta sicura

E[] a;

a = newArray(size);

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

Per estendere a più dimensioni, basta aggiungere []i parametri di dimensione e dimensione newInstance()( Tè un parametro di tipo, clsè un Class<T>, d1attraverso d5sono numeri interi):

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);

Vedi Array.newInstance()per i dettagli.

In Java 8, possiamo fare una sorta di creazione di array generici usando un riferimento lambda o metodo. Questo è simile all'approccio riflessivo (che passa a Class), ma qui non stiamo usando la riflessione.

@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);
    }
}

Ad esempio, questo è usato da <A> A[] Stream.toArray(IntFunction<A[]>).

Questo potrebbe anche essere fatto prima di Java 8 usando classi anonime ma è più ingombrante.

Questo è trattato nel capitolo 5 (Generics) di Effective Java, 2nd Edition , item 25 ... Preferisci gli elenchi agli array

Il codice funzionerà, sebbene genererà un avviso non controllato (che è possibile eliminare con la seguente annotazione:

@SuppressWarnings({"unchecked"})

Tuttavia, sarebbe probabilmente meglio utilizzare un elenco anziché un array.

C'è una discussione interessante di questo bug / funzionalità sul sito del progetto OpenJDK .

Non è necessario passare l'argomento Class al costruttore. Prova questo.

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 + "]";
    }
}

e

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

risultato:

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

I generici Java funzionano controllando i tipi in fase di compilazione e inserendo i cast appropriati, ma cancellando i tipi nei file compilati. Ciò rende le librerie generiche utilizzabili da un codice che non comprende i generici (che è stata una decisione di progettazione deliberata) ma che significa che normalmente non è possibile scoprire quale sia il tipo in fase di esecuzione.

Il Stack(Class<T> clazz,int capacity)costruttore pubblico richiede di passare un oggetto Class in fase di esecuzione, il che significa che le informazioni sulla classe sono disponibili in fase di esecuzione per codificare ciò che ne ha bisogno. E il Class<T>modulo indica che il compilatore verificherà che l'oggetto Class che passi sia esattamente l'oggetto Class per il tipo T. Non una sottoclasse di T, non una superclasse di T, ma precisamente T.

Ciò significa quindi che è possibile creare un oggetto array del tipo appropriato nel proprio costruttore, il che significa che il tipo degli oggetti archiviati nella raccolta verrà controllato nei relativi tipi nel punto in cui vengono aggiunti alla raccolta.

Ciao anche se il thread è morto, vorrei attirare la tua attenzione su questo:

Generics viene utilizzato per il controllo del tipo durante il tempo di compilazione:

• Pertanto, lo scopo è verificare che ciò che entra sia ciò di cui hai bisogno.
• Ciò che ritorni è ciò di cui il consumatore ha bisogno.
• Verificare questo:

Non preoccuparti degli avvisi di typecasting quando scrivi una classe generica. Preoccupati quando lo stai usando.

E questa soluzione?

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

Funziona e sembra troppo semplice per essere vero. C'è qualche inconveniente?

Guarda anche questo codice:

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;
}

Converte un elenco di qualsiasi tipo di oggetto in una matrice dello stesso tipo.

Ho trovato un modo semplice e veloce che funziona per me. Nota che l'ho usato solo su Java JDK 8. Non so se funzionerà con le versioni precedenti.

Sebbene non sia possibile creare un'istanza di un array generico di un parametro di tipo specifico, è possibile passare un array già creato a un costruttore di classi generico.

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

    // ...

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

    // Do whatever with the array...
}

Ora in linea di principio possiamo creare l'array in questo modo:

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

        // ...

    }
}

Per una maggiore flessibilità con gli array, è possibile utilizzare un elenco collegato, ad es. ArrayList e altri metodi trovati nella classe Java.util.ArrayList.

L'esempio sta usando la riflessione Java per creare un array. In genere, non è consigliabile, poiché non è un errore di battitura. Invece, ciò che dovresti fare è semplicemente usare un Elenco interno ed evitare l'array.

Passaggio di un elenco di valori ...

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

Ho creato questo frammento di codice per creare un'istanza riflettente di una classe che viene passata per una semplice utility di test automatizzata.

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});
}

Nota questo segmento:

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

per array che inizia dove Array.newInstance (classe di array, dimensione di array) . La classe può essere sia primitiva (int.class) che object (Integer.class).

BeanUtils fa parte della primavera.

In realtà un modo più semplice per farlo, è creare una matrice di oggetti e lanciarla nel tipo desiderato come nell'esempio seguente:

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

dove SIZEè una costante ed Tè un identificatore di tipo

Il cast forzato suggerito da altre persone non ha funzionato per me, gettando un'eccezione al casting illegale.

Tuttavia, questo cast implicito ha funzionato bene:

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

dove Item è una classe che ho definito contenente il membro:

private K value;

In questo modo si ottiene una matrice di tipo K (se l'articolo ha solo il valore) o qualsiasi tipo generico che si desidera definire nella classe Item.

Nessun altro ha risposto alla domanda su cosa sta succedendo nell'esempio che hai pubblicato.

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;
}

Come altri hanno già detto, i generici vengono "cancellati" durante la compilazione. Quindi in fase di esecuzione un'istanza di un generico non sa quale sia il suo tipo di componente. La ragione di ciò è storica, Sun voleva aggiungere generici senza rompere l'interfaccia esistente (sia sorgente che binaria).

Gli array invece do conoscono il loro tipo di componente in fase di esecuzione.

Questo esempio risolve il problema facendo in modo che il codice che chiama il costruttore (che conosce il tipo) passi un parametro che indichi alla classe il tipo richiesto.

Quindi l'applicazione costruirà la classe con qualcosa del genere

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

e il costruttore ora sa (in fase di esecuzione) qual è il tipo di componente e può usare tali informazioni per costruire l'array tramite l'API di reflection.

Array.newInstance(clazz, capacity);

Finalmente abbiamo un cast di tipo perché il compilatore non ha modo di sapere che l'array restituito Array#newInstance()è il tipo corretto (anche se lo sappiamo).

Questo stile è un po 'brutto ma a volte può essere la soluzione meno negativa per la creazione di tipi generici che devono conoscere il loro tipo di componente in fase di esecuzione per qualsiasi motivo (creazione di array o creazione di istanze del loro tipo di componente, ecc.).

Ho trovato una sorta di soluzione a questo problema.

La riga seguente genera un errore di creazione di array generico

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

Tuttavia, se incapsulo List<Person>in una classe separata, funziona.

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


public class PersonList {

    List<Person> people;

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

Puoi esporre le persone nella classe PersonList tramite un getter. La riga sotto ti darà un array, che ha un List<Person>in ogni elemento. In altre parole, matrice di List<Person>.

PersonList[] personLists=new PersonList[10];

Avevo bisogno di qualcosa del genere in un codice su cui stavo lavorando e questo è quello che ho fatto per farlo funzionare. Finora nessun problema.

È possibile creare un array di oggetti e lanciarlo su E ovunque. Sì, non è un modo molto pulito per farlo, ma dovrebbe almeno funzionare.

prova questo.

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

Una soluzione semplice, sebbene disordinata, sarebbe quella di nidificare una seconda classe "titolare" all'interno della classe principale e utilizzarla per conservare i dati.

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

Forse non correlato a questa domanda ma mentre stavo ottenendo l' generic array creationerrore " " per l'utilizzo

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

Scopro i seguenti lavori (e ho lavorato per me) con @SuppressWarnings({"unchecked"}):

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

Mi chiedo se questo codice creerebbe un array generico efficace?

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;
}

Modifica: Forse un modo alternativo di creare un tale array, se la dimensione richiesta fosse nota e piccola, sarebbe semplicemente quello di alimentare il numero richiesto di "null" nel comando zeroArray?

Anche se ovviamente questo non è versatile come usare il codice createArray.

Puoi usare un cast:

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

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

In realtà ho trovato una soluzione davvero unica per bypassare l'impossibilità di avviare un array generico. Quello che devi fare è creare una classe che accetta la variabile generica T in questo modo:

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

e poi nella tua classe di array basta che inizi così:

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

iniziare a new Generic Invoker[] causerà un problema con deselezionato, ma in realtà non dovrebbero esserci problemi.

Per ottenere dall'array dovresti chiamare l'array [i] .variable in questo modo:

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

Il resto, come il ridimensionamento dell'array, può essere fatto con Arrays.copyOf () in questo modo:

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

E la funzione Aggiungi può essere aggiunta in questo modo:

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++;
}

Secondo vnportnoy la sintassi

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

crea una matrice di riferimenti null, da compilare come

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

che è sicuro.

private E a[];
private int size;

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

La creazione di array generici non è consentita in java ma puoi farlo in questo modo

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