Conversion sûre de String en BigDecimal

Question

J'essaie de lire des valeurs BigDecimal à partir d'une chaîne de caractères. Disons que j'ai cette chaîne : "1,000,000,000.999999999999999" et je veux en extraire une valeur BigDecimal. Quelle est la façon de le faire ?

Tout d'abord, je n'aime pas les solutions utilisant les remplacements de chaînes de caractères (remplacement des virgules, etc.). Je pense qu'il devrait y avoir un formateur qui fasse ce travail pour moi.

J'ai trouvé une classe DecimalFormatter, mais comme elle fonctionne avec des doubles, on perd une grande partie de la précision.

Alors, comment puis-je le faire ?

Answer 1

Vérifiez setParseBigDecimal dans DecimalFormat. Avec ce setter, parse retournera un BigDecimal pour vous.

Answer 2

String value = "1,000,000,000.999999999999999";
BigDecimal money = new BigDecimal(value.replaceAll(",", ""));
System.out.println(money);

---

Code complet pour prouver qu'aucun NumberFormatException est lancé :

import java.math.BigDecimal;

public class Tester {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        String value = "1,000,000,000.999999999999999";
        BigDecimal money = new BigDecimal(value.replaceAll(",", ""));
        System.out.println(money);
    }
}

Sortie

1000000000.999999999999999

Answer 3

L'exemple de code suivant fonctionne bien (la locale doit être obtenue dynamiquement).

import java.math.BigDecimal;
import java.text.NumberFormat;
import java.text.DecimalFormat;
import java.text.ParsePosition;
import java.util.Locale;

class TestBigDecimal {
    public static void main(String[] args) {

        String str = "0,00";
        Locale in_ID = new Locale("in","ID");
        //Locale in_ID = new Locale("en","US");

        DecimalFormat nf = (DecimalFormat)NumberFormat.getInstance(in_ID);
        nf.setParseBigDecimal(true);

        BigDecimal bd = (BigDecimal)nf.parse(str, new ParsePosition(0));

        System.out.println("bd value : " + bd);
    }
}

Answer 4

Le code pourrait être plus propre, mais cela semble faire l'affaire pour différentes langues.

import java.math.BigDecimal;
import java.text.DecimalFormatSymbols;
import java.util.Locale;

public class Main
{
    public static void main(String[] args)
    {
        final BigDecimal numberA;
        final BigDecimal numberB;

        numberA = stringToBigDecimal("1,000,000,000.999999999999999", Locale.CANADA);
        numberB = stringToBigDecimal("1.000.000.000,999999999999999", Locale.GERMANY);
        System.out.println(numberA);
        System.out.println(numberB);
    }

    private static BigDecimal stringToBigDecimal(final String formattedString,
                                                 final Locale locale)
    {
        final DecimalFormatSymbols symbols;
        final char                 groupSeparatorChar;
        final String               groupSeparator;
        final char                 decimalSeparatorChar;
        final String               decimalSeparator;
        String                     fixedString;
        final BigDecimal           number;

        symbols              = new DecimalFormatSymbols(locale);
        groupSeparatorChar   = symbols.getGroupingSeparator();
        decimalSeparatorChar = symbols.getDecimalSeparator();

        if(groupSeparatorChar == '.')
        {
            groupSeparator = "\\" + groupSeparatorChar;
        }
        else
        {
            groupSeparator = Character.toString(groupSeparatorChar);
        }

        if(decimalSeparatorChar == '.')
        {
            decimalSeparator = "\\" + decimalSeparatorChar;
        }
        else
        {
            decimalSeparator = Character.toString(decimalSeparatorChar);
        }

        fixedString = formattedString.replaceAll(groupSeparator , "");
        fixedString = fixedString.replaceAll(decimalSeparator , ".");
        number      = new BigDecimal(fixedString);

        return (number);
    }
}

Answer 5

Voici comment je m'y prendrais :

public String cleanDecimalString(String input, boolean americanFormat) {
    if (americanFormat)
        return input.replaceAll(",", "");
    else
        return input.replaceAll(".", "");
}

Évidemment, si cela devait être intégré dans un code de production, ce ne serait pas aussi simple.

Je ne vois aucun problème à simplement supprimer les virgules de la chaîne.