Discussion :

[momedalhouma]

Bonjour , en faite je suis entrain de lire un livre sur les generiques et les collections , et y'a un exemple qui m'a stoppé et j'arrive pas à comprendre : voici l'exemple:

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
class Promote {
 
    public static List<String> promote(List<Object> objs) {
        for (Object o : objs) {
            if (!(o instanceof String)) {
                throw new ClassCastException();
            }
        }
        return (List<String>) (List<?>) objs; // unchecked cast
    }
 
    public static void main(String[] args) {
        List<Object> objs1 = Arrays.<Object>asList("one", "two");
        List<Object> objs2 = Arrays.<Object>asList(1, "two");
        List<String> strs1 = promote(objs1);
        assert (List<?>) strs1 == (List<?>) objs1;
        boolean caught = false;
        try {
            List<String> strs2 = promote(objs2);
        } catch (ClassCastException e) {
            caught = true;
        }
        assert caught;
    }
}

Ce que j'ai pas compris c'est dans la méthode promote, cette ligne là:

Code :

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

return (List<String>)(List<?>)objs; // unchecked cast

moi je pense qu'on peut se contenter de faire ça :

Code :

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

return (List<String>)objs;

Pourquoi on a du convertir la liste d'object en une liste<?> puis en une liste de String.
Merci beaucoup pour vos explications.

J'ai oublié de dire que l'exemple permet de convertir une liste d’objects en liste de String.

[adiGuba]

Salut,


Perso je trouve cela super-crade (d'ailleurs le compilateur génère des warning !).
Si on utilise des Generics c'est pour utiliser un type précis, pas pour utiliser Object. Ce genre de conversion est bien bizarre et il est un peu étrange d'avoir besoin de cela...



Sinon, on ne peut pas se contenter d'un return (List<String>)objs; car le compilateur va générer une erreur : objs est un List<Object> et il ne peut pas être caster en List<String>.

"L'astuce" consiste à rajouter un cast vers List<?> au milieu pour empêcher le compilateur de vérifier le typeage.
Du coup le cast d'un List<?> vers un List<String> est autorisé (principalement pour des raisons de compatibilités ascendante).

Mais il est erroné de faire cela !
D'ailleurs le compilateur le signale par un warning "unchecked cast", qui se libère de sa responsabilité envers la vérification du typeage.

En clair le compilateur ne garantie plus que le typeage soit correcte, et cela pourrait très bien générer des ClassCastException.


Exemple :

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
        List<Object> objs = new ArrayList<Object>();
        objs.add("Hello");
        objs.add("World");
 
        List<String> strs = promote(objs); // OK
 
        for (String s : strs) {
        	System.out.println(s); // OK
        }
 
        objs.add(new Date());
 
        for (String s : strs) {
        	System.out.println(s); // ClassCastException: java.util.Date
        }

Bref c'est le genre de code à éviter !


a++

[thelvin]

Dans le cas rarissime où on a bel et bien généré une List<Object> car elle pouvait contenir n'importe quoi, mais qu'on atteint un état où on est désormais convaincu que la List ne devrait contenir que des String et qu'il faudrait l'exploiter sous forme de List<String>,

je préfère m'en rendre certain en construisant une nouvelle List<String> au lieu d'essayer de "convertir" la List<Object>.

Code :

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

1
2
3
4
5
6
7
public static List<String> asStrings(List<Object> objs) {
  List<String> strings = new ArrayList<>();
  for (Object o : objs) {
    strings.add((String)objs); // ClassCastException si on s'est trompé
  }
  return strings;
}

C'est moins efficace, mais en cas d'erreur on le sait tôt, grâce au compilateur et au cast au plus tôt.