Java - Format Décimal.analyser le retour du double de la valeur avec le nombre de décimales spécifié

Je veux être en mesure de convertir une chaîne de caractères à un Double donné un nombre de décimales dans une chaîne de format. Donc,"###, ##0.000" devrait me donner une Double à 3 décimales.

Modifier - ajout de plus d'info à ce qui se passe

L'utilisateur entre la valeur de l'INTERFACE (qui est entrée dans une Chaîne. La règle est cette valeur est limitée à 3 décimales. Le code sous-jacent stocke la valeur dans la base de données qui est ensuite utilisé dans un calcul. Par conséquent, la fuite décimales va provoquer les calculs d'être légèrement à ce qui serait attendu.

J'ai le code suivant:

try {
        //output current locale we are running under (this happens to be "nl_BE")
        System.out.println( "Current Locale is " + Locale.getDefault().toString() );

        //number in Central European Format with a format string specified in UK format
        String numberCE = "1,234567"; //1.234567
        String formatUK = "###,##0.000";

        //do the format
        DecimalFormat formatterUK = new DecimalFormat( formatUK );
        Double valCEWithUKFormat = formatterUK.parse( numberCE ).doubleValue();

        //I want the number to DPs in the format string!!!
        System.out.println( "CE Value     " + numberCE + " in UK format (" + formatUK + ") is "
        + valCEWithUKFormat );

    } catch( ParseException ex ) {
        System.out.println("Cannot parse number");
    }
}

La DecimalFormat semble ignorer la chaîne de format et me donne l'intégralité de la chaîne comme un Double de 1.234567.

Peut DecimalFormat être obligé d'utiliser la chaîne de format lors de l'analyse? Ai-je raté quelque chose?

Acclamations,

Andez

Voulez-vous vraiment essayer de faire cela? En raison de la perte de précision sur la conversion de base 10 en binaire (la représentation interne), vous risquez de ne pas obtenir ce que vous attendez.

OriginalL'auteur Andez | 2011-01-19

17

DecimalFormat est utilisée pour les deux distinctes fins: entrée lors de l'analyse et de la mise en forme de la sortie. Si vous voulez faire les deux, vous devrez utiliser le format de l'objet à deux reprises.

Si vous voulez prendre que la valeur et le format de sortie, en restreignant le nombre de chiffres significatifs, vous devez utiliser le format de l'objet nouveau. Cette fois, il utilise vos règles de mise en forme pour créer une chaîne de sortie à partir d'une valeur numérique:
```
String output = formatterUK.format(valCEWithUKFormat.doubleValue() );
```
Cela vous donnera la sortie de 1,235

Il semble que vous voulez que cette valeur numérique qui sera présenté dans la 1.235 format. Pour ce faire, vous devez formater la sortie à l'aide des paramètres régionaux spécifiques (si le vôtre utilise un format différent).

CEPENDANT, je vous recommande d'aborder ce problème différemment:
```
String text = "1,234567";
NumberFormat nf_in = NumberFormat.getNumberInstance(Locale.GERMANY);
double val = nf_in.parse(text).doubleValue();

NumberFormat nf_out = NumberFormat.getNumberInstance(Locale.UK);
nf_out.setMaximumFractionDigits(3);
String output = nf_out.format(val);
```
Quelques remarques:
- D'entrée de l'analyse devraient être séparés de formatage de sortie. Surtout quand vous commencez à lancer dans de multiples paramètres régionaux.
- Permettre la bibliothèque standard pour faire le gros du travail pour déterminer ce qui valide la valeur d'entrée est un endroit donné. Vous avez juste besoin de choisir un des paramètres Régionaux (j'ai choisi l'ALLEMAGNE, mais ce serait évidemment travailler avec les autres). Toujours utiliser les Locales lorsque cela est possible. Ne pas essayer de recréer le formatage des chaînes de caractères.
- Toujours stocker votre valeur d'entrée SÉPARÉ de tout formatage de sortie. C'est à dire, si vous souhaitez afficher uniquement les trois chiffres dans la sortie, c'est bien, mais le magasin de la double valeur de toute façon.
OriginalL'auteur robert_x44

En tenant compte de ce que vous avez dit j'ai modifié mon code un peu pour couvrir les différents paramètres régionaux. La clé est de prendre une valeur de chaîne de caractères dans un format localisé à un Double qui est arrondi, basée sur la chaîne de format.

La chaîne de format est toujours basée au royaume-UNI format avec séparateurs de décimales spécifié en tant que "." et des milliers de séparateurs spécifiée ",".

Je suis en utilisant le DecimalFormat d'abord d'analyser le format localisé en fonction d'un jeu de paramètres régionaux. Cela donne un Double équivalent de la chaîne correctement. J'utilise ensuite un BigDecimal pour gérer l'arrondissement. Je peux obtenir le nombre de décimales de la DecimalFormat instance et d'appel setScale sur le BigDecimal pour effectuer l'arrondi.

Le code initial de la structure a été modifiée pour vous permettre de voir ce qui se passe sous différents paramètres régionaux circonstances merci @RD01 pour en notant l'importance d'autres lieux.

J'ai maintenant le code comme suit:

private void runTests3() {
//output current locale we are running under
System.out.println( "Current Locale is " + Locale.getDefault().toString() );
//number in Central European Format with a format string specified in UK format
String numbersInEuropeanFormatString[] = new String[] { "1.000,234567", "1,2345678", "1.222.333,234567" };
String formatUK = "###,##0.0000";
//output numbers using the german locale
System.out.println("Output numbers using the German locale\n");
for(String num : numbersInEuropeanFormatString ) {
formatNumberAsDouble(num, formatUK, Locale.GERMAN);
}
//output numbers using the UK locale.  
//this should return unexpected results as the number is in European format
System.out.println("Output numbers using the UK locale\n");
for(String num : numbersInEuropeanFormatString ) {
formatNumberAsDouble(num, formatUK, Locale.UK);
}
//output numbers using new DecimalFormat( formatUK ) - no locale specified
System.out.println("\n\nOutput numbers using new DecimalFormat( " + formatUK + " )\n");
for(String num : numbersInEuropeanFormatString ) {
formatNumberAsDouble( num, formatUK, null);
}
}
private void formatNumberAsDouble(String value, String format, Locale locale) {
NumberFormat formatter;
int decimalPlaces;
//create the formatter based on the specified locale
if( locale != null ) {
formatter = NumberFormat.getNumberInstance(locale);
//creating the above number format does not take in the format string
//so create a new one that we won't use at all just to get the
//decimal places in it
decimalPlaces = (new DecimalFormat(format)).getMaximumFractionDigits();
} else {
formatter = new DecimalFormat( format );
decimalPlaces = formatter.getMaximumFractionDigits();
}
//get the result as number
Double result = null;
try {
result = formatter.parse( value ).doubleValue();
} catch( ParseException ex ) {
//not bothered at minute
}
//round the Double to the precision specified in the format string
BigDecimal bd = new BigDecimal(result );
Double roundedValue = bd.setScale( decimalPlaces, RoundingMode.HALF_UP ).doubleValue();
//output summary
System.out.println("\tValue = " + value);
System.out.println( locale == null  ? "\tLocale not specified" : "\tLocale = " + locale.toString());
System.out.println( format == null || format.length() == 0 ? "\tFormat = Not specified" : "\tFormat = " + format);
System.out.println("\tResult (Double) = " + result);
System.out.println("\tRounded Result (Double) (" + decimalPlaces + "dp) = " + roundedValue);
System.out.println("");
}

Ce produit la sortie suivante:

Current Locale is nl_BE
Output numbers using the German locale
Value = 1.000,234567
Locale = de
Format = ###,##0.0000
Result (Double) = 1000.234567
Rounded Result (Double) (4dp) = 1000.2346
Value = 1,2345678
Locale = de
Format = ###,##0.0000
Result (Double) = 1.2345678
Rounded Result (Double) (4dp) = 1.2346
Value = 1.222.333,234567
Locale = de
Format = ###,##0.0000
Result (Double) = 1222333.234567
Rounded Result (Double) (4dp) = 1222333.2346
Output numbers using the UK locale
Value = 1.000,234567
Locale = en_GB
Format = ###,##0.0000
Result (Double) = 1.0
Rounded Result (Double) (4dp) = 1.0
Value = 1,2345678
Locale = en_GB
Format = ###,##0.0000
Result (Double) = 1.2345678E7
Rounded Result (Double) (4dp) = 1.2345678E7
Value = 1.222.333,234567
Locale = en_GB
Format = ###,##0.0000
Result (Double) = 1.222
Rounded Result (Double) (4dp) = 1.222
Output numbers using new DecimalFormat( ###,##0.0000 )
Value = 1.000,234567
Locale not specified
Format = ###,##0.0000
Result (Double) = 1000.234567
Rounded Result (Double) (4dp) = 1000.2346
Value = 1,2345678
Locale not specified
Format = ###,##0.0000
Result (Double) = 1.2345678
Rounded Result (Double) (4dp) = 1.2346
Value = 1.222.333,234567
Locale not specified
Format = ###,##0.0000
Result (Double) = 1222333.234567
Rounded Result (Double) (4dp) = 1222333.2346

OriginalL'auteur Andez

0

Bien sûr vous pouvez. L'essayer:
```
String in = "1,234567";
System.out.println(NumberFormat.getNumberFormat(new Locale("fr", "FR")).parse(in));
System.out.println(NumberFormat.getNumberFormat(new Locale("en", "GB")).parse(in));
```
Clairement qu'ils résultent de sortie différente de la première lecture 1.234567 et la deuxième 1234567. Peut-être il ya quelque chose de mal avec votre modèle? De toute façon la dernière ligne, il serait la meilleure façon d'obtenir la UK format standard.

OriginalL'auteur Mark Peters

La restriction de décimales dans DecimalFormat est vraiment conçu pour l'utilisation dans le format() méthode et n'ont pas beaucoup d'effet dans la parse() méthode.

Afin d'obtenir ce que vous voulez, vous avez besoin de ceci:

    try {
//output current locale we are running under (this happens to be "nl_BE")
System.out.println("Current Locale is " + Locale.getDefault().toString());
//number in Central European Format with a format string specified in UK format
String numberCE = "1,234567"; //1.234567
String formatUK = "###,##0.000";
//do the format
DecimalFormat formatterUK = new DecimalFormat(formatUK);
Double valCEWithUKFormat = formatterUK.parse(numberCE).doubleValue();
//first convert to UK format string
String numberUK = formatterUK.format(valCEWithUKFormat);
//now parse that string to a double
valCEWithUKFormat = formatterUK.parse(numberUK).doubleValue();
//I want the number to DPs in the format string!!!
System.out.println("CE Value     " + numberCE + " in UK format (" + formatUK + ") is " + valCEWithUKFormat);
} catch (ParseException ex) {
System.out.println("Cannot parse number");
}

Vous devez d'abord obtenir le numéro de la royaume-UNI chaîne de format et d'analyser ensuite ce nombre, à l'aide du royaume-UNI formateur. Vous obtenez le résultat que vous recherchez. NB, ce sera arrondir le nombre à 3 décimales, de ne pas tronquer.

En passant, je suis un peu surpris de voir que votre royaume-UNI formateur est en mesure d'analyser les CE format de nombre. Vous devriez vraiment être l'analyse de l'origine avec un numéro de CE format de l'analyseur.

OriginalL'auteur mluisbrown

Vous devez vous connecter pour publier un commentaire.