Discussion :

[Invité]

Bonjour,

Je rencontre quelques soucis dans le développement de mon programme.

PS : Les noms de classe sont inventés .

Voici la classe CasePion

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public class CasePion extends Observable implements controler.ICasePion
{
    private enum State
    {
        /* ... */
        private static final String[] STRINGS = new String[] { "*", "-", foo,  foo };
        @Override public String toString() { return STRINGS[this.ordinal()]; }
    }
 
     /* ......... */
}

Et voici ma classe EchecCase imaginons :

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
public class EchecCase 
{
 
    /* Quelques attributes */
 
 
@Override public String toString() {
 
    final String tabu = "\t";
    String string = new String(tabu);
 
    for(int i=0; i < DIM; i++) 
        for(int j=0;  j< DIM; j++)
        string+= casepion(i, j).toString() +...
 
    return string;
}

Donc c est la ligne [code] s+= casepion(i, j).toString() +.. qui m'a l'air de poser soucis.

En remplaçant le casepion(i, j).toString() par "*", ça m'affiche bien un tableau contenant les étoiles, par contre on mettant casepion(i, j).toString(), la fonction toString devant retourné un/des éléments du tableau STRINGS n'est pas du tout appelée ..
J'ai des résultats bizarre du style

Code :

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

1
2
[java]	modele.CasePion@a62b39f	modele. modele.casePion@55fe910c	modele.CasePion@3be4d6ef	modele.CasePion@2cdb03a1	modele.CasePion@5ecb5608	modele.CasePion@777d57d6	et
     [java] 	etc .. pour tout les éléments du damier ( à la place des * , - .. )

Apparemment la méthode toString() renvoie le nom de la classe suivie de son adresse..
Du coup un indice là-dessus ?
Quels pourraient être les problèmes à ce non appel ?

Merci

[thelvin]

la fonction toString devant retourné un/des éléments du tableau STRINGS n'est pas du tout appelée ..

Laquelle ? Je ne vois aucune méthode toString() dans cette classe...

Du coup un indice là-dessus ?
Quels pourraient être les problèmes à ce non appel ?

L'absence d'une telle méthode à appeler, doit y être pour quelque chose.

[adiGuba]

Salut,

Apparemment la méthode toString() renvoie le nom de la classe suivie de son adresse..
Du coup un indice là-dessus ?
Quels pourraient être les problèmes à ce non appel ?

Ce qui correspond à l'implémentation par défaut de toString() hérité de Object.
La classe CasePion n'a pas redéfinie la méthode toString().



Sinon petite remarque sur ce code :

Code :

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

1
2
3
4
5
6
    String s = new String(TAB);
 
    for(int i=0; i < DIM; i++) for(int j=0;  j< DIM; j++)
        s+= casepion(i, j).toString() + ( j < DIM-1 ? TAB : LS + TAB);
 
    return s;

Il est particulièrement mauvais car l'opération += sur les String implique la création de plusieurs objets temporaires.
Et dans une (double) boucle, cela peut être catastrophique d'un point de vue occupation mémoire !

Il est préférable de passer par un StringBuilder :

Code :

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

1
2
3
4
5
6
7
    StringBuilder sb = new StringBuilder(TAB);
 
    for(int i=0; i < DIM; i++) for(int j=0;  j< DIM; j++)
        sb.append(casepion(i, j))
		.append( j < DIM-1 ? TAB : LS + TAB);
 
    return sb.toString();

a++

[Invité]

D'accord merci beaucoup des conseils.

Edit;

[Invité]

Je me permets de demander quel est l avantage du StringBuilder par rapport à ma concaténation ?

[joel.drigo]

Je me permets de demander quel est l avantage du StringBuilder par rapport à ma concaténation ?

Salut,

c'est pourtant indiqué :

Il est particulièrement mauvais car l'opération += sur les String implique la création de plusieurs objets temporaires.
Et dans une (double) boucle, cela peut être catastrophique d'un point de vue occupation mémoire !

Ca peut aussi avoir un certains impact sur les perf...

En fait, chacun de tes += correspond à la création d'un StringBuilder (avec un buffer (un tableau de char) dont la taille est la longueur de la chaîne de départ (avant le +=) + 16, puis il est retransformé en String.

Si tu as 50 itérations par exemple (50 colonnes), ça fait 50 créations de StringBuilder, avec induit 50 petits tableaux de char pour les buffers (de plus en grand, au fur et mesure que ta chaîne s'agrandit lors des concaténations des nouvelles colonnes), puis autant de création de String. Pour peu que ce qui se trouve après le += a une taille supérieur à 16 caratères; et ça fera encore un tableau de plus à créer.

Autant créer un seul StringBuilder avec une seul création de buffer [enfin, il est créé au début avec une taille (qu'on peut estimer éventuellement), et il s'agrandit au besoin : comme c'est multiplié par 2 (+2) à chaque agrandissement, il y a rapidement assez de buffer (voire trop), pour peu que tu aies beaucoup de colonnes, et tu as beaucoup moins d'allocation de tableaux avec un StringBuilder, qu'avec un +=], et une seule transformation en String à la fin de la méthode toString().