Cet article vise à résoudre le problème `ClassCastException` rencontré lors de l'utilisation de tableaux génériques en Java. Nous explorerons en profondeur les limitations d'interaction entre les génériques Java et les tableaux, et proposerons trois solutions efficaces?: utiliser les tableaux `Object[]`, utiliser `ArrayList` pour remplacer les tableaux et créer des tableaux génériques par réflexion, aidant les développeurs à éviter les erreurs de conversion de type et à écrire un code générique plus robuste.

Lors de l'utilisation de génériques Java, la création directe d'un tableau générique rencontrera certaines limitations, entra?nant une exception ClassCastException. Cela est d? à un conflit entre le mécanisme d'effacement générique de Java et la covariance des tableaux. En termes simples, le compilateur Java ne peut pas déterminer le type concret du type générique T au moment de l'exécution, il ne peut donc pas créer en toute sécurité un tableau de type T[]. L'utilisation directe de new T[size] pour créer un tableau générique n'est pas autorisée.

Ci-dessous, nous présenterons trois solutions à ce problème.

Solution 1?: utiliser le tableau Object[]

Si votre code ne nécessite pas une sécurité de type stricte et peut accepter la vérification de type au moment de l'exécution, vous pouvez utiliser un tableau Object[] au lieu d'un tableau générique.

 classe publique Test2 {

    Données Objet[] = nouvel Objet[3]?;

    public static void main (String[] arguments) {
        Test2 t = nouveau Test2();
        t.data[0] = "Amar";
        t.data[1] = "Buddi"?;
        t.data[2] = "chiot"?;

        // La conversion de type est requise lors de l'utilisation de String name = (String) t.data[0];
        System.out.println(nom);
    }
}

Choses à noter?:

• Lors de l'utilisation d'un tableau Object[], une conversion de type explicite est requise lors de la lecture des éléments.
• Si la conversion de type échoue, une ClassCastException peut être levée.
• Cette approche sacrifie la sécurité des types au moment de la compilation et nécessite une vérification de type supplémentaire au moment de l'exécution.

Option 2?:?utiliser ArrayList

ArrayList est un tableau dynamique qui implémente l'interface List et prend en charge les génériques. L'utilisation d'ArrayList évite les problèmes liés à la création directe de tableaux génériques.

 importer java.util.ArrayList?;

classe publique Test2<t> {

    ArrayList<t> data = new ArrayList(3);

    public static void main (String[] arguments) {
        Test2<string> t = new Test2();
        t.data.add("Amar");
        t.data.add("Buddi");
        t.data.add("chiot");

        // Aucune conversion de type requise String name = t.data.get(0);
        System.out.println(nom);
    }
}</string></t></t>

avantage:

• Sécurité du type?: ArrayList effectue une vérification de type au moment de la compilation pour éviter ClassCastException.
• Taille dynamique?: ArrayList peut être redimensionné automatiquement selon les besoins.
• Facile à utiliser?: ArrayList fournit des méthodes riches pour faire fonctionner les éléments.

défaut:

• Par rapport aux tableaux, ArrayList peut avoir une baisse de performances dans certains cas.

Option 3?: Utiliser la réflexion pour créer un tableau générique

Des tableaux génériques peuvent être créés à l'aide du mécanisme de réflexion de Java. Cette méthode nécessite qu'un objet Class de type générique soit spécifié au moment de l'exécution.

 importer java.lang.reflect.Array?;

classe publique Test2<t> {
    Données T[]?;

    @SuppressWarnings("non coché")
    public Test2(Class<t>clazz) {
        data = (T[]) Array.newInstance(clazz, 3);
    }

    public static void main (String[] arguments) {
        Test2<string> t = new Test2(String.class);
        t.data[0] = "Amar";
        t.data[1] = "Buddi"?;
        t.data[2] = "chiot"?;

        System.out.println(t.data[0]);
    }
}</string></t></t>

Choses à noter?:

• Un objet Class de type générique doit être transmis.
• L'annotation @SuppressWarnings("unchecked") est utilisée pour supprimer les avertissements du compilateur.
• Les opérations de réflexion peuvent entra?ner une pénalité en termes de performances.

Résumer

L'utilisation de tableaux génériques en Java nécessite une attention particulière aux problèmes de sécurité des types. En choisissant les méthodes appropriées, vous pouvez éviter les ClassCastExceptions et écrire un code générique plus robuste.

• Si une sécurité de type stricte n'est pas requise, un tableau Object[] peut être utilisé.
• Si vous avez besoin d'une sécurité de type et d'une taille dynamique, vous pouvez utiliser ArrayList.
• Si vous devez utiliser un tableau générique, vous pouvez utiliser la réflexion pour le créer.

La méthode à choisir dépend du scénario d'application et des exigences spécifiques. Dans le développement réel, la solution la plus appropriée doit être sélectionnée en fonction de la situation spécifique.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!