Format numérique

Version imprimable

03/05/2006, 11h37
viscere

Format numérique

Bonjour,

je dois récupérer dans un fichier des valeurs de sommets X Y Z sous la forme :

1 0.00000000000E+00 0.00000000000E+00 0.00000000000E+00
2 0.00000000000E+00 0.20000000000E+01 0.00000000000E+00
3 0.00000000000E+00 0.40000000000E+01 0.00000000000E+00
4 0.00000000000E+00 0.60000000000E+01 0.00000000000E+00
5 0.00000000000E+00 0.80000000000E+01 0.00000000000E+00

je récupere donc chaque string 0.00000000000E+00 etc ... et je le parse grace à la méthode Float.ParseFloat.

Cela ne marche pas il me met des valeurs inexactes. Me suis-je trompé de type?

Merci

Laurent
03/05/2006, 12h07
@ldehan

t'as essayé avec des doubles ?

Code:

Double.parseDouble()
03/05/2006, 12h26
Satch

Pour manipuler des valeursavec autant de chiffres après la virgule, j'éviterai d'utiliser des float, voire même des doubles.

J'irai plutôt manipuler ça avec des BigDecimals.

A moins de vraiment comprendre ce qui se passe pendant les opérations sur les doubles, leurs résultats semblent parfois mystérieux.

Ceci dit, si tu ne fais aucune opération dessus, des doubles devraient aller.
03/05/2006, 13h36
viscere

Bon j y arrive mais des qu il tombe sur des négatifs ca plante :

526 -0.10000003576E+01 0.17320505381E+01 0.66666670144E-01
527 -0.20000000000E+01-0.47699522554E-07 0.66666670144E-01
528 -0.20000000000E+01-0.17484555315E-06 0.10000000894E+00

En fait ca plante car j'utilise les StringTokenizer pour récuperer mes données. Et dans ce cas vu que ceux qui ont fait ce fichier ont pas pensé a mettre un espace de plus donc je récupere le token -0.20000000000E+01-0.47699522554E-07 et donc mon ParseFloat plante. Kelkun aurait il une méthode simple pour récuperer mes 2 chiffres sans que je me lance dans un parsage tout pourri comme je sais si bien le faire??

Merci

Laurent

Salut,

Tu peux utiliser les expressions régulières :

Code:

1
2
3
4
5
6
7
8
9
        String line = "-0.20000000000E+01-0.17484555315E-06 0.10000000894E+00";
 
        Pattern pattern = Pattern.compile("-?[0-9]+\\.[0-9]+E[+-][0-9]{2}");
 
        Matcher matcher = pattern.matcher(line);
        while (matcher.find()) {
            String number = matcher.group();
            // Traitement
        }

Pour en savoir plus suivre les cours et tutoriels pour apprendre Java : http://java.developpez.com/cours/

a++

03/05/2006, 14h01
viscere

Merci Adiguba Ca marche du feu de dieu!!!
Par contre si c pas trop te demander tu peux me modifier ton expression reguliere pour qu elle accepte aussi un entier tout seul ??

[0-9] ca veut dire un chiffre entre 0 et 9 ou une suite infini de chiffre entre 0 et 9???
03/05/2006, 14h09
viscere

c bon merci j ai mis Pattern pattern = Pattern.compile("-?[0-9]+(\\.[0-9]+E[+-][0-9]{2})?"); et ca a l air de marcher.

Encore merci!
03/05/2006, 14h31
viscere

Par contre je voudrais ne pas utiliser de boucle pour pouvoir faire ca:

matcher.find();
String d = matcher.group();
System.out.println("Ifff : "+d);
som.setId(Integer.parseInt(d));

System.out.println("Id : "+matcher.group());
// Recupère X
matcher.find();
som.setX(Double.parseDouble(matcher.group()));
System.out.println("X : "+matcher.group());
// Recupère Y
matcher.find();
som.setY(Double.parseDouble(matcher.group()));
System.out.println("Y : "+matcher.group());
// Recupère Z
matcher.find();
som.setZ(Double.parseDouble(matcher.group()));
System.out.println("Z : "+matcher.group());

Mais ca marche po...
03/05/2006, 14h32
adiGuba

Tu peux même le découper en deux groupes pour authoriser les nombres à virgules sans E :

Code:

Pattern pattern = Pattern.compile("-?[0-9]+(\\.[0-9]+)?(E[+-][0-9]{2})?");

a++
03/05/2006, 14h35
viscere

Ok mais j arrive pas a l'utiliser sans la boucle while le matcher.group() plante si il est pas dans le while.
03/05/2006, 14h45
adiGuba

Citation:

Envoyé par viscere

Ok mais j arrive pas a l'utiliser sans la boucle while le matcher.group() plante si il est pas dans le while.

Tu dois surement faire un find() de trop par rapport aux nombres de valeurs trouvé...

Vérifie bien ta valeur en entrée...

a++