Salut,
Tout d'abord dans un tableau de type Object[] et de dimension 2, on peut toujours mettre un String dans le premier élément et un Float dans le second, ou n'importe quelle instance de n'importe quelle classe d'ailleurs, toute classe étendant Object. Mais on ne peut pas déclarer un tableau dont chaque élément est de type différent : c'est la définition même d'un tableau, que tous les éléments sont vu avec le même type. Mais le type du tableau et la classe des instances dans le tableau sont deux choses différentes : tant que la classe de l'instance est la classe des éléments du tableau, ou une classe qui étend directement ou indirectement (une classe qui étend une classe qui étend ...). Mais, je ne comprends pas ce que le cast de la List vient faire dans l'histoire : un cast permet juste d'adapter le type d'une instance à un autre type compatible (étendant le premier), comme dans ce code :
1
2
3
4
| Object[] array1 = new Integer[]{1, 2, 3};
for(Integer value : (Integer[])array1) {
System.out.println(value * 10);
} |
Ou le cast est utile pour que value soit Integer (ce qui est possible parce que le tableau est Integer[]).
Mais il n'y a aucun moyen de caster le tableau suivant en quoique ce soit :
Object[] array1 = new Object[]{"toto", 1f};
puisque c'est un Object[] (on ne peut le caster qu'en Object[], ce qui n'a aucun intérêt).
Et puisque les 2 valeurs sont de classes différentes, dont aucune n'étant l'autre, on ne peut que faire un Object[].
Si on avait ça :
Object[] array1 = new Object[]{1d, 1f};
On pourrait écrire :
Object[] array1 = new Number[]{1d, 1f};
parce que les classes Float et Double étendent toutes les deux Number
On pourrait écrire également :
Object[] array1 = new Number[]{1d, 1d};
Mais on ne pourrait pas écrire ensuite :
1
2
3
| for(Double value : (Double[])array1) { // class cast exception : un tableau de Number n'est pas un tableau de Double, même s'il contient que des Double
System.out.println(value * 10);
} |
De la même façon :
1
2
3
4
| Object[] array1 = new Number[]{1d, 1f};
for(Double value : (Double[])array1) { // class cast exception : un tableau de Number n'est pas un tableau de Double
System.out.println(value * 10);
} |
de même qu'on pourrait pas plus écrire :
1
2
3
4
| Object[] array1 = new Number[]{1d, 1f};
for(Object value : array1) {
System.out.println(((Double)value) * 10); // class cast exception sur le second item : un Float n'est pas un Double
} |
ni plus
Object[] array1 = new Float[]{1d, 1f}; // 1d est un double pas un float
ou :
Object[] array1 = new Double[]{1d, 1f}; // 1f est un float pas un double
Ceci étant dit : il ne faut pas oublier que Java est un langage orienté objet et qu'on peut faire des classes. Pourquoi chercher à vouloir stocker des données de types différents dans des tableaux, alors qu'on peut le faire dans une classe de manière. Un tableau est fait pour traiter et stocker des données de même type et les traiter par itération.
Si tu fais une classe :
1
2
3
4
| public class Exemple {
public String text;
public Float nombre;
} |
On peut faire :
1
2
3
4
| List<Exemple> list = new ArrayList<>();
list.add(exemple);
String machin = list.get(0).text;
float truc = list.get(0).nombre; |
Et dans cette liste on peut stocker des exemples, avec un attribut de type String, et un de type Float. Ce qui te permet de les traiter en tant qu'instance d'une classe adaptée à leur gestion.
Si, pour un traitement en particulier, tu as besoin absolument d'avoir un tableau, tu peux toujours faire :
1
2
3
4
5
6
7
8
9
10
| public class Exemple {
public String text;
public Float nombre;
public Object[] toArray() {for(
return new Object[]{text, nombre};
}
} |
Et tu appelles toArray() quand tu as besoin du tableau :
1
2
3
4
| List<Exemple> list = ...
for(Exemple item : list) {
method(item.toArray());
} |
avec
public void method(Object[] array) {...}
Et si à l'inverse tu as en entrée un Object[] dont la première valeur est un String et la seconde un Float, tu ne pourras qu'écrire quelque chose comme ça (d'ailleurs, tu peux voir tous les contrôles qu'on doit faire, à cause de la permissivité de Object[], si on veut être sûr qu'il n'y ait pas d'erreur, et qui montre qu'une classe avec des attributs typés est beaucoup mieux) :
1
2
3
4
5
6
7
8
9
10
11
| public Exemple createExemple(Object[] array) {
if ( array==null || array.length<2 ) throw new IllegalArgumentException();
if ( (array[0]== null || array[0] instanceof String) && (array[I]==null || array[1] instanceof Float ) {
Exemple exemple = new Exemple();
exemple.text = (String)array[0];
exemple.nombre=(Float)array[1];
return exemple;
}
else {
throw new IllegalArgumentException();
} |
Créer un ArrayList de plusieurs types
Répondre avec citation
La plupart des réponses à vos questions sont déjà dans les 
Envoyé par fetano
Partager