Discussion :

[gids01]

Bonjour,

J'aimerais remplir un tableau avec des angles que je calcule au fur et à mesure.

J'ai déclaré ma variable et mon tableau comme ceci:

Code :

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

1
2
float normal_angle = 0;
edgesNormals = new float[10];

Maintenant, que je fasse ceci:

Code :

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

edgesNormals = normal_angle;

ou cela:

Code :

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

edgesNormals[] = normal_angle;

Il met l'erreur suivante:
cannot convert from float to float[]

Si par contre je met:

Code :

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

edgesNormals[2] = normal_angle;

Ca fonctionne.

Ce qu'il y a, c'est que je ne sais pas à quel indice mettre l'angle, il faut le mettre à la suite de ceux déjà mis.

Y'a-t-il une solution?

Merci pour vos réponses

[Kikito]

Le mieux est d'utiliser un java.util.ArrayList.

Code :

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

1
2
3
ArrayList<Float> liste = new ArrayList<Float>(10);
liste.add(...);
liste.add(...);

Si tu veux ensuite le repasser en tableau tu fais un :

Code :

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

Float[] tableau = liste.toArray(new Float[0]);

[adiGuba]

Salut,

Si tu veux ensuite le repasser en tableau tu fais un :

Code :

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

Float[] tableau = liste.toArray();

Plutôt ceci :

Code java :

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

Float[] tableau = liste.toArray(new Float[0]);

a++

[Kikito]

J'étais en train d'éditer quand tu as répondu, tu as bien sûr raison, le type retourné par toArray() étant du Object.

[Kikito]

C'est d'ailleurs bizarre/dommage que maintenant avec les générics il n'y ait pas une méthode du genre :

Code :

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

1
2
3
4
5
public E[] toArray() {
    E[] newTab = (E[])new Object[size];
    System.arraycopy(elementData, 0, newTab, 0, size);
    return newTab;
}

Car là on a une création d'objet et deux tests pour rien dans 95% du temps.

[adiGuba]

Ce n'est pas possible pour deux raisons :

• Les types génériques sont vérifié à la compilation et perdu à l'exécution.
• Le type des tableaux ne peuvent être vérifié que pendant l'exécution.

a++

[Kikito]

J'ai peur de ne pas comprendre

Je parle biensûr d'avoir rajouter cette fonction à la classe ArrayList, pourquoi ne serait-ce pas possible ? ton point 1 n'est pas gênant et pour ton point 2 le tableau utilisé en interne par l'ArrayList étant de type E :

Code :

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

1
2
3
4
5
 /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer.
     */
    private transient E[] elementData;

On est sur de pouvoir créer un tableau de type E, sinon l'arraylist n'aurait même pas pû être crée - ils s'autorisent d'ailleurs beaucoup de warning de type "type safety" sans cette même classe.
En fait ce que je voulais faire c'est juste un clone de la table utilisée en interne.

[adiGuba]

Je parle biensûr d'avoir rajouter cette fonction à la classe ArrayList, pourquoi ne serait-ce pas possible ? ton point 1 n'est pas gênant et pour ton point 2 le tableau utilisé en interne par l'ArrayList étant de type E :

Le type du tableau est déclaré en tant que type E[], mais en vérité il ne s'agit que d'un tableau d'objet Object[] comme tu peux le voir à l'initialisation :

Code :

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

this.elementData = (E[])new Object[initialCapacity];

Cela produit un warning car le cast vers (E[]) ne veut rien dire car E n'est pas connu à l'exécution, donc cela revient à écrire ceci :

Code :

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

this.elementData = (Object[])new Object[initialCapacity];

en déclarant elementData en tant que Object[].


Bref en interne ArrayList utilise un Object[] mais n'y ajoute que des objet du type E via la vérification à la compilation...

Ici le E[] sert avant tout à simplifier un peu le code et à limiter le nombre de cast...


Le problème c'est que pour retourner un tableau du bon type, il faut connaitre ce type à l'exécution (puisque le type des tableaux est vérifié à l'exécution). Or le type des generics est perdu (à l'exécution E est remplacé par Object avec des cast implicite).

Donc la méthode toArray() ne peut pas renvoyer le bon type de tableau car elle ne connait pas le type exact du paramétrage des générics, alors que la méthode toArray(T[]) possède cette information (le type du tableau en paramètre est récupéré).

Ce n'est donc pas possible.
A titre d'exemple essaye de coder la méthode suivante en renvoyant un tableau du bon type :

Code :

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

1
2
3
4
5
6
7
class MyClass<E> {
 
    public E[] createArray() {
        return null;
    }
 
}

Tu verras que ce n'est pas possible tel quel.



Le seul moyen étant de spécifier le type de E en passant un objet de type Class en paramètre, par 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
class MyClass<E> {
 
    private final Class<E> type;
 
    public MyClass(Class<E> type) {
        this.type = type;
    }
 
    @SuppressWarnings("unchecked")
    public E[] createArray() {
        return (E[]) Array.newInstance(this.type, 5);
    }
 
}

Il faut utiliser du @SuppressWarnings pour la méthode Array.newInstance() qui n'est pas generic (parce qu'elle retourne un Object et non pas un Object[]), mais ca marche...

Par contre on est obligé de spécifier le type de E en paramètre du constructeur : cela aurait un impact énorme sur les codes existant si on devait faire cela avec les différentes collections...


Bref les Generics ont une implémentation particulière basé sur le type-erasure (effacement du type -- c'est à dire qu'à l'exécution on utilise le type de base et non pas le type spécifique comme avec d'autre langage), avec leurs défauts et leurs avantages : Les Generics ne sont pas des Templates comme les autres !


Toutefois, il existe une RFE pour "supprimer" le type-erasure des generics, ce qui pourrait permettre de faire des chose du tyle :

Code :

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

1
2
3
    public E[] createArray() {
        return new E[5];
    }

http://bugs.sun.com/bugdatabase/view...bug_id=5098163


a++

[Kikito]

Merci pour ta réponse, très intéressant.

Sinon il pourrait y avoir le moyen de récupérer le type d'un des éléments :

Code :

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

1
2
3
4
5
6
7
8
9
public E[] toArray() {
    if (size==0){
    	return null;
    }
    E[] newTab = (E[])java.lang.reflect.Array.
                        newInstance(elementData[0].getClass(), size);
    System.arraycopy(elementData, 0, newTab, 0, size);
    return newTab;
}

Mais c'est vrai que c'est pas très propre et qu'on est obligé de renvoyer null ou de lancer une exception si l'arraylist est vide.

[®om]

[/B]Toutefois, il existe une RFE pour "supprimer" le type-erasure des generics, ce qui pourrait permettre de faire des chose du tyle :
[/COLOR][/SIZE]

Code :

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

1
2
3
    public E[] createArray() {
        return new E[5];
    }

Tu peux expliquer un peu?

[adiGuba]

Mais c'est vrai que c'est pas très propre et qu'on est obligé de renvoyer null ou de lancer une exception si l'arraylist est vide.

Le problème c'est surtout que le type du tableau pourrait être différent du type de l'ArrayList, puisque le premier élément pourrait très bien être un type fils...

Exemple :

Code :

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

1
2
3
4
        List<Number> list = new ArrayList<Number>();
        list.add(new Double(0.0));
 
        Number[] n = list.toArray(); // retournerai un Double[]

Tu peux expliquer un peu?

J'ai donné le lien : http://bugs.sun.com/bugdatabase/view...bug_id=5098163

Le status est en RFE, cela signifie que c'est à l'étude... par contre rien ne certifie que ce sera vraiment le cas un jour (c'est juste à l'étude).


a++