java generic array how simulate generic arrays java
Ce didacticiel explique comment simuler la fonctionnalité d'un tableau générique en Java à l'aide d'un tableau d'objets et également en utilisant la classe de réflexion avec un exemple simple:
Nous avons déjà discuté Génériques Java dans l'un de nos précédents tutoriels. Java autorise les classes génériques, les méthodes, etc. qui peuvent être déclarées indépendamment des types. Cependant, Java n'autorise pas le tableau à être générique.
La raison en est qu'en Java, les tableaux contiennent des informations relatives à leurs composants et ces informations sont utilisées pour allouer de la mémoire lors de l'exécution. Lorsque des génériques sont utilisés, en raison de l'effacement de type, le code d'octet ne contient aucune information générique.
=> Visitez ici pour apprendre Java à partir de zéro.
Ce que vous apprendrez:
Tableau générique en Java
Si vous avez défini un tableau générique, le type de composant ne sera pas connu lors de l'exécution. Il n'est donc pas conseillé de définir les tableaux comme génériques en Java.
Une définition de tableau générique est comme indiqué ci-dessous:
E () newArray = new E(length);Le compilateur ne connaît pas le type exact qui doit être instancié car les informations de type ne sont pas disponibles au moment de l'exécution.
Ainsi, au lieu de tableaux, chaque fois que des génériques sont nécessaires, vous devriez préférer le composant de liste du framework Java Collections. Cependant, vous pouvez créer des structures génériques de type tableau à l'aide du tableau d'objets et de la fonction de réflexion de Java.
Ces deux approches qui nous permettent de définir des tableaux de différents types de données sont expliquées ci-dessous en détail.
sites Web pour télécharger des vidéos sur youtube
Créer et initialiser la baie générique
Dans cette section, créons une structure de type tableau qui est de nature générique. En utilisant ces structures, vous pourrez créer des tableaux en fournissant le type de données comme argument.
Utilisation du tableau d'objets
Cette approche utilise le tableau de type Objects comme membre de la classe de tableau principal. Nous utilisons également les méthodes get / set pour lire et définir les éléments du tableau. Ensuite, nous instancions la classe de tableau principale qui nous permet de fournir le type de données selon les besoins.
Cela simule le tableau générique.
Le programme suivant illustre l'utilisation du tableau d'objets pour créer une structure de type tableau générique.
import java.util.Arrays; class Array { private final Object() obj_array; //object array public final int length; // class constructor public Array(int length) { // instantiate a new Object array of specified length obj_array = new Object (length); this.length = length; } // get obj_array(i) E get(int i) { @SuppressWarnings('unchecked') final E e = (E)obj_array(i); return e; } // set e at obj_array(i) void set(int i, E e) { obj_array(i) = e; } @Override public String toString() { return Arrays.toString(obj_array); } } class Main { public static void main(String() args){ final int length = 5; // creating integer array Arrayint_Array = new Array(length); System.out.print('Generic Array :' + ' '); for (int i = 0; i Production:
Dans le programme ci-dessus, nous avons défini une classe Array qui est générique. Le tableau d'objets est un membre de la classe qui est instancié à l'aide d'un constructeur et d'une longueur. Nous utilisons également les méthodes génériques get et set qui sont utilisées pour lire et définir un élément de tableau d'un type particulier.
Ensuite, nous créons des instances de cette classe de tableau. Lors de la création des instances, nous pouvons spécifier le type souhaité. Dans le programme ci-dessus, nous avons créé deux tableaux de type Integer et String, puis nous remplissons ces tableaux avec les valeurs appropriées (en utilisant la méthode set).
Enfin, en utilisant la méthode «toString» remplacée, nous affichons le contenu de chacune de ces instances.
Utiliser la réflexion
Dans cette approche, nous utilisons une classe de réflexion pour créer un tableau générique dont le type ne sera connu qu'au moment de l'exécution.
meilleur optimiseur gratuit pour windows 10
L'approche est similaire à la précédente avec une seule différence, c'est-à-dire que nous utilisons la classe de réflexion dans le constructeur lui-même pour instancier un tableau d'objets en passant explicitement les informations de type de données au constructeur de classe.
Ce type d'informations est passé à la méthode de réflexion Array.newInstance.
Le programme suivant montre l'utilisation de la réflexion pour créer un tableau générique . Notez que toute la structure du programme est similaire à l'approche précédente avec juste la différence dans l'utilisation des fonctionnalités de réflexion.
importjava.util.Arrays; class Array { private final E() objArray; public final int length; // class constructor public Array(ClassdataType, int length){ // create a new array with the specified data type and length at runtime using reflection this.objArray = (E()) java.lang.reflect.Array.newInstance(dataType, length); this.length = length; } // get element at objArray(i) Eget(int i) { returnobjArray(i); } // assign e to objArray(i) void set(int i, E e) { objArray(i) = e; } @Override public String toString() { return Arrays.toString(objArray); } } class Main { public static void main(String() args){ final int length = 5; // create array with Integer as data type Arrayint_Array = new Array(Integer.class, length); System.out.print('Generic Array:' + ' '); for (int i = 0; i Production:
Le programme ci-dessus montre des tableaux de deux types, à savoir Integer et String créés à partir de la classe générique Arrays.
Erreur de création de matrice générique
Nous avons déjà discuté des implications de la création de tableaux génériques en Java et pourquoi il n'est pas possible d'avoir des tableaux génériques en Java. Une autre explication à cela est que les tableaux en Java sont covariants alors que les génériques ne le sont pas. Les génériques sont invariants.
Par covariance, nous entendons qu'un tableau du sous-type peut être attribué à sa référence de supertype.
Cela signifie que l'instruction suivante fonctionnera correctement.
Number numArray() = new Integer(10);Comme Integer est un sous-type de Number, l'instruction ci-dessus se compile correctement.
Mais si nous utilisons le même concept avec les génériques, cela ne fonctionnera pas, c'est-à-dire qu'avec les génériques, nous ne pouvons pas attribuer un sous-type générique à un super-type générique.
L'instruction ListobjList = new ArrayList (); donnera une erreur de compilation car les génériques ne sont pas covariants comme les tableaux.
En gardant à l'esprit la raison ci-dessus, nous ne pouvons pas avoir quelque chose comme ci-dessous:
public static ArrayList() myarray = new ArrayList(2);Cette instruction échouera à se compiler avec l'erreur, 'Création de tableau générique' car nous ne pouvons pas déclarer un tableau de références à un type générique spécifique.
Nous pouvons cependant créer un tableau de références à un type générique spécifique en utilisant un caractère générique. L'instruction ci-dessus peut être compilée avec succès avec une légère modification de l'utilisation d'un caractère générique comme indiqué ci-dessous.
public static ArrayListmyarray = new ArrayList(5);L'instruction ci-dessus sera compilée avec succès.
Le programme suivant montre une démonstration de l'utilisation de caractères génériques.
entretien de développeur net questions et réponses
import java.util.*; //generic array class classArr { T tarray(); Arr(T myarray()) { tarray = myarray; } @Override public String toString() { return Arrays.toString(tarray); } } public class Main { public static void main(String() args) { // Arrtarray() = new Arr(5); //error: generic array creation //initialize new array objects Arr arr1 = new Arr(new Integer(){2,4,6,8,10}); System.out.print('Array with Integer type:' + ' '); System.out.println(arr1); Arr arr2 = new Arr(new String(){'aa', 'bb', 'cc', 'dd'}); System.out.print('Array with String type:' + ' '); System.out.println(arr2); //define array objects using wildcard Arrarr3() = new Arr(5); arr3(0) = new Arr(new Integer(){10, 20, 30, 40, 50}); System.out.println('Integer array: ' + arr3(0)); arr3(1) = new Arr(new Float(){1.1f, 2.2f, 3.3f, 4.4f, 5.5f}); System.out.println('Float array: ' + arr3(1)); } } Production:
Dans le programme ci-dessus, nous avons la première instruction de la méthode principale qui indique l'invariance des génériques. Cette instruction fera clignoter l'erreur de compilation (indiquée dans les commentaires). La prochaine création de tableau est conforme aux règles des génériques et donc ils se compilent avec succès.
Questions fréquemment posées
Q # 1) Qu'est-ce qu'un tableau générique?
Répondre: Les tableaux indépendants du type de données et dont le type d'informations est évalué à l'exécution sont des tableaux génériques. Les génériques sont similaires aux modèles en C ++.
Q # 2) Pouvez-vous créer un tableau générique en Java?
Répondre: Les tableaux sont covariants en Java, c'est-à-dire que tout tableau de sous-classe peut être affecté à un tableau de supertype. Les génériques, cependant, sont invariants, c'est-à-dire que vous ne pouvez pas affecter un tableau de type de sous-classe au type de superclasse.
Deuxièmement, les informations génériques sont supprimées de la JVM et, par conséquent, le tableau dont l'allocation de mémoire est effectuée au moment de l'exécution ne sait pas quel type doit être attribué au tableau. Ainsi, les tableaux et les génériques ne vont pas bien ensemble en Java.
Q # 3) Qu'est-ce que le type E en Java?
Répondre: agit comme un espace réservé pour les génériques et représente tout type d'élément.
Q # 4) Qu'est-ce que l'effacement de type en Java?
Répondre: Un processus exécuté par le compilateur Java par lequel les types paramétrés utilisés dans les génériques sont supprimés et mappés aux types bruts dans le code d'octet. En tant que tel, le code d'octet ne contient aucune information sur les génériques.
Q # 5) Qu'est-ce qu'un type brut en Java?
Répondre: Les types bruts sont des types génériques sans utiliser le paramètre type. Par exemple. La liste est un type brut; alors que List est un type paramétré.
Conclusion
En Java, le tableau générique ne peut pas être défini directement, c'est-à-dire que vous ne pouvez pas avoir un type paramétré affecté à une référence de tableau. Cependant, à l'aide de tableaux d'objets et de fonctions de réflexion, vous pouvez simuler la création de tableaux génériques.
Nous avons vu ces deux approches dans ce didacticiel ainsi que les détails de l'erreur de création de tableau générique et les possibilités d'empêcher une telle erreur. En un mot, en Java, vous pouvez dire que les tableaux et les génériques ne vont pas de pair car les tableaux sont covariants tandis que les génériques sont invariants.
=> Consultez le guide de formation Perfect Java ici.
lecture recommandée
- Java Array - Comment imprimer des éléments d'un tableau en Java?
- Tutoriel Java Array Length avec des exemples de code
- Tutoriel de réflexion Java avec des exemples
- Java Array - Déclarer, créer et initialiser un tableau en Java
- Introduction aux tableaux Java et aux concepts associés
- Tutoriel Java Generics avec des exemples
- Tutoriel Java SWING: Conteneur, composants et gestion des événements
- Types de données Java, boucles, tableaux, commutateurs et assertions
