[String] Compter les caractères et afficher des espaces

Version imprimable

Bonjour à tous,
j'ai un petit problème, j'aimerais aligner une matrice, et je compte compter le nombre de caractères de mon élément de matrice (compris entre -999.999 et 999.999). Et en fonction du nombre obtenu, afficher un certain nombre d'espaces. Comment pourrais-je faire?

J'ai essayer de cette méthode-là
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 //Sous fonction: aligne et écrit la matrice static void ecrireMatrice(double[][] matrice, int nbl){ int l,c;//variables de ligne et colonne int nbelem;//nombre de caractère de l'élément matrice for (l=0; l<nbl; l++){ for (c=0; c<nbl; c++){ matrice[l][c]= Math.round(matrice[l][c]*1000)/1000. ; nbelem=matrice[l][c].length(); System.out.print(" "+matrice[l][c]+(7-nbelem*" ")); } System.out.print("\n"); } System.out.println("\n"); }
Et ça ne marche pas à la compillation. Comment dois-je faire? et est-ce que j'utilise la bonne méthode

25/05/2005, 22h05
Yodalf
bonjour,

Code:

System.out.print(" "+matrice[l][c]+(7-nbelem*" "));

c'est un peut euh déroutant :lol:!!
en java on ne peu faire (7-nbelem*" "), il faut refaire un boucle :
Code:

1 2 3 4 for(int i=0; i<7-nbelem; i++) { System.out.print(" "); }
25/05/2005, 23h02
VitamineC

Salut,

Code:

nbelem=matrice[l][c].length();

Qu'est ce que c'est ?? C'est sensé donner quoi ?
Bref, il faut parcourir toutes colonnes et trouver
le nbre qui possede le + de caractere et decaller
comme l'indique Yodalf...
Bonne prog et bon amusement avec les effets de bord
:wink:

OK, je vais essayer, merci. Mais cette ligne pose problème, il ne veut pas compter dans des doubles.

Code:

nbelem=matrice[l][c].length();

J'ai réglé une partie du problème, pour la partie entière, ça marche, mais pour la partie décimale, je ne vois pas comment je pourrais faire... Voici ma sous-fonction actuelle, je ne sais pas comment je pourrais faire pour l'alléger, ou pour aller plus rapidement.

Code:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
//Sous fonction: aligne et écrit la matrice
 	static void ecrireMatrice(double[][] matrice, int nbl){
       int l,c;//variables de ligne et colonne
       int nbdeci;//nombre de décimales
       int i;//variable de boucle
 
       for (l=0; l<nbl; l++){
          for (c=0; c<nbl; c++){
 
             //Arrondis les différents éléments de la matrice à 3 chiffres après la virgule.
             NumberFormat formatter = NumberFormat.getNumberInstance();
             formatter.setMaximumFractionDigits(3);
             String mat=formatter.format(matrice[l][c]);
             double element=Double.parseDouble(mat);
 
             //Affiche les espaces avant la virgule
             if (element<0){
             	/*if (element<=-100){
             		System.out.print(" ");
             	}*/
             	if (element<=-10 && element>-100){
             		System.out.print(" ");
             	}
             	if (element<0 && element>-10){
             		System.out.print("  ");
             	}
             }
             else{
             	if (element>=100 && element <1000){
             		System.out.print(" ");
             	}
             	if (element>=10 && element<100){
             		System.out.print("  ");
             	}
             	if (element>=0 && element <10){
             		System.out.print("   ");
             	}
             }
 
             //Affiche l'élément
             System.out.print(element);
 
             //Affiche les espaces après la virgule, je cale ici
             nbdeci=(element-Math.abs(element)).length(); //cette ligne ne fonctionne pas
             for (i=0; i<nbdeci; i++){
             	System.out.print(" ");                     	
             }
          }
          System.out.print("\n");
        }
        System.out.println("\n");
    }

Si vous avez des propositions, n'hésitez pas. Merci d'avance

26/05/2005, 04h43
VitamineC

C'est au niveau du string "mat" que tu dois faire .lenght()
et trouver ce nbre qui te permettra de decaller.

Etant donné que ça ne marchait pas, j'ai essayé autrement.

Code:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
 	//Sous fonction: aligne et écrit la matrice
 	static void ecrireMatrice(double[][] matrice, int nbl){
       int l,c;//variables de ligne et colonne
       int i;//variable de boucle
       String intch;//valeur entière sous forme de chaine
       int nbint;//nombre de caractères avant la virgule
       int inter;//nombre qui servira à savoir combien d'espace il faut mettre après la vrigule
       for (l=0; l<nbl; l++){
          for (c=0; c<nbl; c++){
 
             //Arrondis les différents éléments de la matrice à 3 chiffres après la virgule.
             NumberFormat formatter = NumberFormat.getNumberInstance();
             formatter.setMaximumFractionDigits(3);
             String mat=formatter.format(matrice[l][c]);
             double element=Double.parseDouble(mat);
 
             //Affiche les espaces avant la virgule
             intch=(""+(int)(element));
             nbint=intch.length();
             for (i=0; i<(4-nbint);i++){
             	System.out.print(" ");
             }
 
             //Affiche l'élément
             System.out.print(element);
 
             //Affiche les espaces après la virgule
             inter=(int)(element*1000);
             if (inter%10==0){
             	System.out.print(" ");
             	if (inter%100==0){
             		System.out.print(" ");
             		if (inter%1000==0){
             			System.out.print(" ");
             		}
             		else{
             			System.out.print("");
            		}
             	}
             	else{
             		System.out.print("");
             	}
 
             }
             else{
             	System.out.print("");
             }
          }
          System.out.print("\n");
        }
        System.out.println("\n");
    }

Mais il plante quand il s'agit d'éléments contenant des nombres décimaux. Autrement pour les entiers, ca marche au poil. Je ne comprends pas d'où vient le problème. Mais j'ai besoin que ca marche, surtout quand je calcule les matrices inverse. Aidez-moi svp.

Merci d'avance

27/05/2005, 02h43
VitamineC

Salut,
J'ai bien reçu ton mp... désolé de te repondre aussi tardivement.
La methode que tu veux utiliser n'etant pas celle à laquelle je pense,
càd avec un calcul du decalage avant toute boucle d'affichage,
je ne vois pas comment t'aider plus.
Bonne chance.
27/05/2005, 20h19
v4np13

Je désespère, je n'ai toujours pas trouvé de solution idéale. J'aimerais arriver à un résultat comme celui ci:

En gros que les unitées soit alignées, que les virgules soit alignées,... et les nombre sont compris entre -999.999 et 999.999.

Aidez moi s'il vous plait, sans ça une grosse partie de mon programme plante... :(

Merci d'avance

Avant de désespérer, cherchons ! :)

Ci-dessous un exemple, basé sur ton code, qui semble fonctionner.
Je l'ai fait rapidement : c'est largement améliorable !

Nicolas

Code:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
public class Matrice {
 
    //Sous fonction: aligne et écrit la matrice
    static void ecrireMatrice(double[][] matrice, int nbl){
        int l,c;//variables de ligne et colonne
        int i;//variable de boucle
        String intPartieEntiere;//valeur entière sous forme de chaine
        int nbint;//nombre de caractères avant la virgule
        int inter;//nombre qui servira à savoir combien d'espace il faut mettre après la vrigule
        for (l=0; l<nbl; l++){
            for (c=0; c<nbl; c++){
                double element = matrice[l][c];
 
                //Arrondir à 10^-3
                if (element>=0) {
                    element *= 1000;
                    element = (int)(element+.5);
                    element /= 1000;
                } else {
                    element *= 1000;
                    element = (int)(element-.5);
                    element /= 1000;
                }
 
 
                //Affiche les espaces avant la virgule
                intPartieEntiere=(""+(int)(element));
                nbint=intPartieEntiere.length();
                for (i=0; i<(4-nbint);i++){
                    System.out.print(" ");
                }
 
                //Affiche la partie entiere et le point
                System.out.print(intPartieEntiere+".");
 
                //Calcule la partie decimale
                int partieDecimale = (int) ((element - ((int) element))*1000);
                if (partieDecimale<0) { partieDecimale = - partieDecimale; }
                String partieDecimaleString=(""+partieDecimale);
 
                //Affiche la partie decimale
                System.out.print(partieDecimaleString);
 
                //Affiche les espaces apres le nombre
                nbint=partieDecimaleString.length();
                for (i=3; i>=nbint;i--){
                    System.out.print(" ");
                }
            }
            System.out.print("\n"); // fin de ligne
        }
    }
 
    public static void main(String[] args) {
        double[][] matrice = {{-13.2, 442.5675, -3.1005}, {34., -345.56, 6.5}, {7.12, -38., -349.67855}};
        ecrireMatrice(matrice, 3);
    }
 
}

Sortie :

Code:

1
2
3
 -13.199  442.567   -3.100 
  34.0   -345.560    6.500 
   7.120  -38.0   -349.678

Autre solution... en lisant la Javadoc !

Extrait de celle de NumberFormat :

Citation:

You can also use forms of the parse and format methods with ParsePosition and FieldPosition to allow you to:

progressively parse through pieces of a string
align the decimal point and other areas
For example, you can align numbers in two ways:
If you are using a monospaced font with spacing for alignment, you can pass the FieldPosition in your format call, with field = INTEGER_FIELD. On output, getEndIndex will be set to the offset between the last character of the integer and the decimal. Add (desiredSpaceCount - getEndIndex) spaces at the front of the string.

D'où le code :

Code:

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
import java.text.DecimalFormat;
import java.text.FieldPosition;
import java.text.NumberFormat;
 
public class Matrice {
 
    //Sous fonction: aligne et écrit la matrice
    static void ecrireMatrice(double[][] matrice, int nbl){
        // on suppose que les nombres sont compris entre -999 et 999
        // donc :
        int nbMAXIdeCaracteresAvantVirgule = 4; // pour tenir compte de l'éventuel signe "-"
        DecimalFormat df = new DecimalFormat("##0.###");
        // donc :
        int nbMAXIdeCaracteresApresVirgule = 3;
        FieldPosition fp1 = new FieldPosition(NumberFormat.INTEGER_FIELD);  // pour étudier ce qui se passe AVANT la virgule
        FieldPosition fp2 = new FieldPosition(NumberFormat.FRACTION_FIELD); // pour étudier ce qui se passe APRES la virgule
        int nbDeCaracteresAvantVirgule;
        int nbDeCaracteresApresVirgule;
        StringBuffer aAfficher; // chaine représentant le nombre a afficher
        double element; // element courant de la matrice
        for (int l=0; l<nbl; l++){
            for (int c=0; c<nbl; c++){
                element = matrice[l][c];
                aAfficher = df.format(element, new StringBuffer(), fp1);
                // rajout des espaces au debut
                nbDeCaracteresAvantVirgule = fp1.getEndIndex();
                for (int i=0; i<(nbMAXIdeCaracteresAvantVirgule-nbDeCaracteresAvantVirgule); i++) {
                    aAfficher.insert(0, " "); // 0 = insertion au début
                }
                // rajout des espaces à la fin
                StringBuffer el2 = df.format(element, new StringBuffer(), fp2);
                nbDeCaracteresApresVirgule = fp2.getEndIndex()-fp2.getBeginIndex();
                if (nbDeCaracteresApresVirgule == 0) {
                    aAfficher.append(" "); // pour compenser l'absence de virgule
                }
                for (int i=0; i<(nbMAXIdeCaracteresApresVirgule-nbDeCaracteresApresVirgule); i++) {
                    aAfficher.append(" ");
                }
                // affichage final
                System.out.print(aAfficher.toString());
                System.out.print("  "); // espace entre deux nombres
            }
            System.out.print("\n"); // fin de ligne
        }
    }
 
    public static void main(String[] args) {
        double[][] matrice = {{-13.2, 442.5675, -3.1005}, {34., -345.56, 6.5}, {7.12, -38., -349.67855}};
        ecrireMatrice(matrice, 3);
    }
 
}

Sortie :

Code:

1
2
3
 -13,2     442,568    -3,1    
  34      -345,56      6,5    
   7,12    -38      -349,679

Avertissement : c'est ma première excursion dans le monde merveilleux de NumberFormat => il y a peut-être plus astucieux !

Nicolas

28/05/2005, 11h19
v4np13

Excellent Nicolas !! Tu me sors d'un pétrin ouff. Un grand merci :ccool:

J'ai testé les deux codes, ils fonctionnent tout les deux à merveille et j'ai opté pour la première qui est plus à ma portée (niveau compréhension).

Merci de m'avoir débloqué, je vais pouvoir continuer :D