Discussion :

[tolliob]

Bonjour à tous,


J'aurais besoin, en java, de créer un tableau d'éléments dont le type est un générique.

Mais... A cause du mécanisme d'effacement lors de la compilation, ce n'est pas possible.

Pour éviter ce problème, j'ai vu que l'on peut utiliser la syntaxe : LinkedList<?>[] tableau = new LinkedList<?>[taille];

Aucun détail n'était donné dans ce que j'ai trouvé.

Quelqu'un connait il cet opérateur ? (est ce bien un opérateur ?)
Comment faire, sachant que les éléments de tableau sont de type T, pour les caster en T de manière sécurisé ?


Merci à tous pour vos réponses, qui seront précieuses !

Tolliob

[thelvin]

On ne peut pas. Si ce n'est pas possible ce n'est pas possible, il n'y a pas lieu de se demander comment le rendre possible.

Cesse de vouloir un tableau de génériques. Utilise une liste de génériques ou un tableau de pas génériques, mais choisis.
Dans certains cas imparfaits, tu pourras aussi vouloir utiliser un tableau de génériques dont l'accès n'est pas sûr.

[adiGuba]

Salut,

Pour compléter les propos de thelvin :

Quelqu'un connait il cet opérateur ? (est ce bien un opérateur ?)

C'est un "wildcard", qui permet de restreindre le typeage Generics.
Ici avec <?> tu indiques au compilateur que tu travailles avec un type paramétré que tu ne connais pas précisément...

Comment faire, sachant que les éléments de tableau sont de type T, pour les caster en T de manière sécurisé ?

Pour avoir quelque chose de sécurisé, il ne faut pas utiliser les tableaux car ils ne sont pas type-safe.
Un code utilisant des tableaux peut compiler sans erreur tout en provoquant des exceptions à l'exécution...


a++

[tolliob]

Merci à tous les deux pour vos réponses !

Effectivement, une liste est utilisable dans mon cas.

Tolliob

[bouye]

Pour pallier ce soucis il suffit en fait passer en paramètre le type des objets contenus dans la liste. Quelque chose dans le genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public static <T> T[] toArray(Class<T> type, List<T> list) {
  return list.toArray((T[]) Array.newInstance(type, list.size()));
}

L’implémentation de toArray(T[]) dans LinkedList appelle également Array.newInstance (avec le cast à T[]) quand on lui passe un tableau qui n'a pas la capacité suffisante pour stocker tous les éléments.
Si tu es sur que tous tes éléments dans ta liste sont de même type, il suffit de récupérer la classe du premier élément de la liste.

[thelvin]

En l'occurrence, le type du tableau n'est pas un paramètre générique, mais un type paramétré générique.
Dans ce cas, un tableau empêche de vérifier la cohérence de type, et si on renonce à la cohérence de type il n'y a pas lieu de vouloir utiliser le paramètre du type paramétré.

[tolliob]

Je dois dire que certaine chose me dépassent...

Qu'est ce qu'un paramètre générique ?

[bouye]

Ca depend en fait ; dans un principe de fabrique comme celle de List<T>.toArray(T[]) ça a parfaitement son sens. Ensuite, dans des contextes où l'utilisation des collections n'est pas forcément recommandé (ex : espace mémoire restreint sur mobile ou embedded par exemple), ou même si on a besoin de performances*, l'utilisation des tableau est toujours recommandée.

*Ce n'est pas pour rien que toutes les méthodes de travail de bas niveau en 2D utilisent des int[] pour gérer la couleur ou les buffers représentant le raster sur lequel dessiner.

[thelvin]

Je dois dire que certaine chose me dépassent...

Qu'est ce qu'un paramètre générique ?

<T> est un paramètre générique.
List<T> est un type paramétré, dont <T> est le paramètre générique.

De ce que tu nous en as dit, tu ne cherches pas à faire des tableaux de T, mais des tableaux de List<T>.

Ca depend en fait ; dans un principe de fabrique comme celle de List<T>.toArray(T[]) ça a parfaitement son sens. Ensuite, dans des contextes où l'utilisation des collections n'est pas forcément recommandé (ex : espace mémoire restreint sur mobile ou embedded par exemple), ou même si on a besoin de performances*, l'utilisation des tableau est toujours recommandée.

*Ce n'est pas pour rien que toutes les méthodes de travail de bas niveau en 2D utilisent des int[] pour gérer la couleur ou les buffers représentant le raster sur lequel dessiner.

Qu'on en ait besoin à un moment ou à un autre pour pallier à certaines insuffisances, c'est une chose. C'est la réalité, on fait pas toujours ce qu'on veut. Dans le même genre, on peut jurer fidélité au typage statique fort, mais pour ranger des trucs en contexte J2EE on les met jamais que dans une Map<Object, Object>, parce qu'un type plus concret demanderait trop de travail d'intégration.

Simplement, les génériques ça sert à vérifier la cohérence de type au moment de la compilation, et quand on les mixe avec des tableaux ils échouent dans ce rôle, et donc qu'ils soient là ou non c'est pareil.
Ceci étant dit, ce n'est le cas qu'au cas où quelqu'un fasse "quelque chose de mal" avec les tableaux génériques. On peut décider de faire le vœu pieux que personne ne fera "quelque chose de mal" avec eux en le sachant ou non, et continuer à profiter des vérifications qui marchent encore.

[bouye]

[...] sur mobile ou embedded [...]

[...] travail de bas niveau en 2D

[...] en contexte J2EE on les met jamais que dans une Map<Object, Object> [...]

Ceci explique cela, nous n'avons pas les mêmes valeurs

[tolliob]

Merci Thelvin pour ces précisions sur type paramètre et paramètre générique.

Je reviens à ma question de base en la précisant...

Je dispose de listes chainées dont le type des éléments est 'LinkedList<T>'. Ce type 'T' ne varie pas et peux donc être considéré comme un paramètre générique constant. Je souhaite transformer mes listes chainées en tableau, sachant que celles-ci représentent en fait une entité pour ce que je suis en train de faire.

Que pensez vous du code suivant ? Quels sont les défauts que vous lui voyez ? Quelles sont les améliorations que l'on pourrait y porter.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
public class MonTypeDeBase {
	private String maChaine;
 
	// ...
	// ...
	// ...
}
 
public class MonTypeIntermediaire {
	private LinkedList<MonTypeDeBase> liste;
 
	// ...
	// ...
	// ...
}
 
public class MesListes {
	private LinkedList<MonTypeIntermediaire> liste;
 
	// ...
	// ...
	// ...
 
	public MonTypeIntermediaire[] transforme() {
		return (MonTypeIntermediaire[]) this.liste.toArray();
	}
 
	// ...
	// ...
	// ...
}

Encore merci pour toutes vos réponses,

[thelvin]

Ben il a le problème qu'il marche pas et fait une belle ClassCastException.
En effet this.liste.toArray(); renvoie un Object[], et tu peux toujours essayer de le caster, ça ne marchera pas car le tableau a bel et bien été créé avec un new Object[taille] et pas un new MonTypeIntermediaire[taille].
Tu pourrais régler ça en faisant this.list.toArray(new MonTypeIntermediaire[this.list.size()]).

Ceci étant dit, on continuera à se demander pourquoi tu veux toujours transformer en tableau et pas garder ce que tu as, des List.