Comment créer un tableau générique en Java?

En raison de l'implémentation de génériques Java, vous ne pouvez pas avoir de code comme celui-ci:

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

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

Comment puis-je implémenter cela tout en maintenant la sécurité des types?

J'ai vu une solution sur les forums Java qui va comme ceci:

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

Mais je ne comprends vraiment pas ce qui se passe.

Je dois vous poser une question en retour: est-ce que vous GenSetêtes "coché" ou "non coché"? Qu'est-ce que ça veut dire?

• Vérifié : frappe forte . GenSetsait explicitement quel type d'objets il contient (c'est-à-dire que son constructeur a été explicitement appelé avec un Class<E>argument, et les méthodes lèveront une exception quand on leur passera des arguments qui ne sont pas de type E. Voir Collections.checkedCollection.

  -> dans ce cas, vous devez écrire:

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

• Décoché : frappe faible . Aucune vérification de type n'est effectuée sur aucun des objets passés en argument.

  -> dans ce cas, vous devez écrire

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

  Notez que le type de composant du tableau doit être l' effacement du paramètre 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];
      }
  
      ...
  }

Tout cela résulte d'une faiblesse connue et délibérée des génériques en Java: il a été implémenté en utilisant l'effacement, donc les classes "génériques" ne savent pas avec quel argument de type elles ont été créées au moment de l'exécution, et ne peuvent donc pas fournir de type- sécurité à moins qu'un mécanisme explicite (vérification de type) ne soit implémenté.

Tu peux le faire:

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

C'est l'un des moyens suggérés pour implémenter une collection générique dans Java efficace; Point 26 . Aucune erreur de type, pas besoin de transtyper le tableau à plusieurs reprises. Cependant, cela déclenche un avertissement car il est potentiellement dangereux et doit être utilisé avec prudence. Comme détaillé dans les commentaires, cela se Object[]fait maintenant passer pour notre E[]type et peut provoquer des erreurs inattendues ou ClassCastExceptions s'il est utilisé de manière non sécurisée.

En règle générale, ce comportement est sûr tant que le tableau de cast est utilisé en interne (par exemple pour sauvegarder une structure de données), et non retourné ou exposé au code client. Si vous devez renvoyer un tableau d'un type générique vers un autre code, la Arrayclasse de réflexion que vous mentionnez est la bonne solution.

Il convient de mentionner que dans la mesure du possible, vous aurez beaucoup plus de plaisir à travailler avec des Lists plutôt qu'avec des tableaux si vous utilisez des génériques. Certes, parfois, vous n'avez pas le choix, mais l'utilisation du cadre de collections est beaucoup plus robuste.

Voici comment utiliser les génériques pour obtenir un tableau du type précis que vous recherchez tout en préservant la sécurité du type (contrairement aux autres réponses, qui vous redonneront un Objecttableau ou entraîneront des avertissements au moment de la compilation):

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

Cela se compile sans avertissements, et comme vous pouvez le voir main, pour n'importe quel type dont vous déclarez une instance GenSetas, vous pouvez l'affecter aà un tableau de ce type, et vous pouvez affecter un élément de aà une variable de ce type, ce qui signifie que le tableau et les valeurs du tableau sont du type correct.

Il fonctionne en utilisant des littéraux de classe comme jetons de type runtime, comme indiqué dans les didacticiels Java . Les littéraux de classe sont traités par le compilateur comme des instances de java.lang.Class. Pour en utiliser un, suivez simplement le nom d'une classe avec .class. Agit donc String.classcomme un Classobjet représentant la classe String. Cela fonctionne également pour les interfaces, les énumérations, les tableaux de n'importe quelle dimension (par exemple String[].class), les primitives (par exemple int.class) et le mot clé void(par exemple void.class).

Classlui-même est générique (déclaré comme Class<T>, où Treprésente le type que l' Classobjet représente), ce qui signifie que le type de String.classest Class<String>.

Ainsi, chaque fois que vous appelez le constructeur pour GenSet, vous passez un littéral de classe pour le premier argument représentant un tableau du GenSettype déclaré de l' instance (par exemple String[].classpour GenSet<String>). Notez que vous ne pourrez pas obtenir un tableau de primitives, car les primitives ne peuvent pas être utilisées pour les variables de type.

A l'intérieur du constructeur, l'appel de la méthode castrenvoie l' Objectargument passé cast à la classe représentée par l' Classobjet sur lequel la méthode a été appelée. L'appel de la méthode statique newInstancedans java.lang.reflect.Arrayrenvoie comme un Objecttableau du type représenté par l' Classobjet passé comme premier argument et de la longueur spécifiée par intpassé comme deuxième argument. Appel de la méthodegetComponentType renvoie un Classobjet représentant le type de composant de la matrice représentée par l' Classobjet sur lequel la méthode a été appelée (par exemple , String.classpour String[].class, nullsi l' Classobjet ne représente pas un tableau).

Cette dernière phrase n'est pas tout à fait exacte. L'appel String[].class.getComponentType()renvoie unClass objet représentant la classe String, mais son type ne l'est Class<?>pas Class<String>, c'est pourquoi vous ne pouvez pas faire quelque chose comme ce qui suit.

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

Il en va de même pour chaque méthode Classqui renvoie un Classobjet.

Concernant le commentaire de Joachim Sauer sur cette réponse (je n'ai pas assez de réputation pour le commenter moi-même), l'exemple utilisant le cast pour T[]entraînera un avertissement car le compilateur ne peut pas garantir la sécurité du type dans ce cas.

Modifier concernant les commentaires d'Ingo:

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

Ceci est la seule réponse qui est de type sûr

E[] a;

a = newArray(size);

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

Pour étendre à plus de dimensions, ajoutez simplement []les paramètres s et dimension à newInstance()( Test un paramètre de type, clsest un Class<T>, à d1travers des d5entiers):

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

Voir Array.newInstance()pour plus de détails.

En Java 8, nous pouvons faire une sorte de création de tableau générique en utilisant une référence lambda ou une méthode. Ceci est similaire à l'approche réflexive (qui passe a Class), mais ici nous n'utilisons pas la réflexion.

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

Par exemple, il est utilisé par <A> A[] Stream.toArray(IntFunction<A[]>).

Cela pourrait également être fait avant Java 8 à l'aide de classes anonymes, mais c'est plus lourd.

Ceci est couvert dans le chapitre 5 (Generics) de Effective Java, 2e édition , point 25 ... Préférez les listes de tableaux

Votre code fonctionnera, bien qu'il génère un avertissement non contrôlé (que vous pouvez supprimer avec l'annotation suivante:

@SuppressWarnings({"unchecked"})

Cependant, il serait probablement préférable d'utiliser une liste au lieu d'un tableau.

Il y a une discussion intéressante sur ce bug / fonctionnalité sur le site du projet OpenJDK .

Vous n'avez pas besoin de passer l'argument Class au constructeur. Essaye ça.

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

et

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

résultat:

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

Les génériques Java fonctionnent en vérifiant les types au moment de la compilation et en insérant les transtypages appropriés, mais en effaçant les types dans les fichiers compilés. Cela rend les bibliothèques génériques utilisables par du code qui ne comprend pas les génériques (ce qui était une décision de conception délibérée) mais ce qui signifie que vous ne pouvez pas normalement savoir quel est le type au moment de l'exécution.

Le Stack(Class<T> clazz,int capacity)constructeur public vous oblige à passer un objet Class au moment de l'exécution, ce qui signifie que les informations de classe sont disponibles au moment de l'exécution pour coder qui en a besoin. Et le Class<T>formulaire signifie que le compilateur vérifiera que l'objet Class que vous passez est précisément l'objet Class pour le type T. Pas une sous-classe de T, pas une superclasse de T, mais précisément T.

Cela signifie alors que vous pouvez créer un objet tableau du type approprié dans votre constructeur, ce qui signifie que le type des objets que vous stockez dans votre collection verra leurs types vérifiés au moment où ils sont ajoutés à la collection.

Salut bien que le fil soit mort, je voudrais attirer votre attention sur ceci:

Les génériques sont utilisés pour la vérification de type pendant la compilation:

• Par conséquent, le but est de vérifier que ce dont vous disposez est ce dont vous avez besoin.
• Ce que vous retournez est ce dont le consommateur a besoin.
• Vérifiez ça:

Ne vous inquiétez pas des avertissements de transtypage lorsque vous écrivez une classe générique. Inquiétez-vous lorsque vous l'utilisez.

Et cette solution?

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

Cela fonctionne et semble trop simple pour être vrai. Y a-t-il un inconvénient?

Regardez aussi ce code:

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

Il convertit une liste de tout type d'objet en un tableau du même type.

J'ai trouvé un moyen rapide et facile qui fonctionne pour moi. Notez que je l'ai utilisé uniquement sur Java JDK 8. Je ne sais pas si cela fonctionnera avec les versions précédentes.

Bien que nous ne puissions pas instancier un tableau générique d'un paramètre de type spécifique, nous pouvons passer un tableau déjà créé à un constructeur de classe générique.

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

    // ...

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

    // Do whatever with the array...
}

Maintenant, en général, nous pouvons créer le tableau comme suit:

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

        // ...

    }
}

Pour plus de flexibilité avec vos tableaux, vous pouvez utiliser une liste chaînée par exemple. ArrayList et d'autres méthodes trouvées dans la classe Java.util.ArrayList.

L'exemple utilise la réflexion Java pour créer un tableau. Cette opération n'est généralement pas recommandée, car elle n'est pas sécurisée. Au lieu de cela, ce que vous devez faire est simplement d'utiliser une liste interne et d'éviter du tout le tableau.

Passer une liste de valeurs ...

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

J'ai fait cet extrait de code pour instancier de manière réfléchie une classe qui est passée pour un simple utilitaire de test automatisé.

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

Notez ce segment:

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

pour le tableau initiant où Array.newInstance (classe de tableau, taille du tableau) . La classe peut être à la fois primitive (int.class) et objet (Integer.class).

BeanUtils fait partie du printemps.

En fait, un moyen plus simple de le faire consiste à créer un tableau d'objets et à le caster selon le type souhaité, comme dans l'exemple suivant:

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

où SIZEest une constante et Test un identificateur de type

Le casting forcé suggéré par d'autres personnes n'a pas fonctionné pour moi, jetant une exception au casting illégal.

Cependant, cette distribution implicite a bien fonctionné:

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

où Item est une classe que j'ai définie contenant le membre:

private K value;

De cette façon, vous obtenez un tableau de type K (si l'élément n'a que la valeur) ou tout type générique que vous souhaitez définir dans la classe Item.

Personne d'autre n'a répondu à la question de savoir ce qui se passe dans l'exemple que vous avez publié.

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

Comme d'autres l'ont dit, les génériques sont "effacés" lors de la compilation. Ainsi, lors de l'exécution, une instance d'un générique ne sait pas quel est son type de composant. La raison en est historique, Sun voulait ajouter des génériques sans casser l'interface existante (à la fois source et binaire).

Les tableaux, en revanche , connaissent leur type de composant lors de l'exécution.

Cet exemple contourne le problème en faisant passer le code qui appelle le constructeur (qui connaît le type) un paramètre indiquant à la classe le type requis.

Donc, l'application construirait la classe avec quelque chose comme

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

et le constructeur sait maintenant (au moment de l'exécution) quel est le type de composant et peut utiliser ces informations pour construire le tableau via l'API de réflexion.

Array.newInstance(clazz, capacity);

Enfin, nous avons un cast de type parce que le compilateur n'a aucun moyen de savoir que le tableau retourné par Array#newInstance() est le type correct (même si nous le savons).

Ce style est un peu moche mais il peut parfois être la moins mauvaise solution pour créer des types génériques qui ont besoin de connaître leur type de composant au moment de l'exécution pour une raison quelconque (création de tableaux ou création d'instances de leur type de composant, etc.).

J'ai trouvé une sorte de solution à ce problème.

La ligne ci-dessous renvoie une erreur de création de tableau générique

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

Cependant, si j'encapsule List<Person>dans une classe distincte, cela fonctionne.

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


public class PersonList {

    List<Person> people;

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

Vous pouvez exposer des personnes de la classe PersonList via un getter. La ligne ci-dessous vous donnera un tableau, qui a un List<Person>dans chaque élément. En d'autres termes, tableau de List<Person>.

PersonList[] personLists=new PersonList[10];

J'avais besoin de quelque chose comme ça dans un code sur lequel je travaillais et c'est ce que j'ai fait pour le faire fonctionner. Jusqu'à présent, aucun problème.

Vous pouvez créer un tableau d'objets et le convertir en E partout. Ouais, ce n'est pas une façon très propre de le faire mais cela devrait au moins fonctionner.

essaye ça.

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

Une solution de contournement simple, quoique compliquée, consisterait à imbriquer une deuxième classe «titulaire» à l'intérieur de votre classe principale et à l'utiliser pour stocker vos données.

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

Peut-être sans rapport avec cette question, mais pendant que j'obtenais l' generic array creationerreur " " pour l'utilisation

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

J'ai découvert les œuvres suivantes (et travaillé pour moi) avec @SuppressWarnings({"unchecked"}):

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

Je me demande si ce code créerait un tableau générique 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;
}

Edit: Peut-être qu'une autre façon de créer un tel tableau, si la taille dont vous aviez besoin était connue et petite, serait de simplement introduire le nombre requis de "null" dans la commande zeroArray?

Bien que ce ne soit évidemment pas aussi polyvalent que l'utilisation du code createArray.

Vous pouvez utiliser un casting:

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

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

En fait, j'ai trouvé une solution assez unique pour contourner l'incapacité à lancer un tableau générique. Ce que vous devez faire est de créer une classe qui accepte la variable générique T comme ceci:

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

puis dans votre classe de tableau, commencez comme ceci:

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

commencer un new Generic Invoker[] entraînera un problème avec non coché mais il ne devrait pas y avoir de problème.

Pour obtenir du tableau, vous devez appeler le tableau [i] .variable comme ceci:

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

Le reste, tel que le redimensionnement du tableau peut être fait avec Arrays.copyOf () comme ceci:

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

Et la fonction d'ajout peut être ajoutée comme suit:

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

Selon vnportnoy, la syntaxe

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

crée un tableau de références nulles, à remplir comme

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

qui est de type sûr.

private E a[];
private int size;

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

La création de tableaux génériques n'est pas autorisée en Java, mais vous pouvez le faire comme

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