web-dev-qa-db-fra.com

Format du numéro de devise Java

Est-il possible de formater une décimale comme suit:

100   -> "100"  
100.1 -> "100.10"

S'il s'agit d'un nombre rond, omettez la partie décimale. Sinon, formatez avec deux décimales.

javacurrencynumber-formatting
72
DD.

J'en doute. Le problème est que 100 n'est jamais 100 si c'est un float, c'est normalement 99.9999999999 ou 100.0000001 ou quelque chose comme ça. 

Si vous souhaitez le formater de cette manière, vous devez définir un epsilon, c'est-à-dire une distance maximale par rapport à un nombre entier, et utiliser le formatage entier si la différence est plus petite et un nombre à virgule sinon.

Quelque chose comme ça ferait l'affaire:

public String formatDecimal(float number) {
  float epsilon = 0.004f; // 4 tenths of a cent
  if (Math.abs(Math.round(number) - number) < epsilon) {
     return String.format("%10.0f", number); // sdb
  } else {
     return String.format("%10.2f", number); // dj_segfault
  }
}
42
extraneon

Je vous recommande d'utiliser le package Java.text: 

double money = 100.1;
NumberFormat formatter = NumberFormat.getCurrencyInstance();
String moneyString = formatter.format(money);
System.out.println(moneyString);

Cela présente l’avantage supplémentaire d’être spécifique aux paramètres régionaux.

Mais, si vous devez, tronquer la chaîne que vous récupérez s'il s'agit d'un dollar entier: 

if (moneyString.endsWith(".00")) {
    int centsIndex = moneyString.lastIndexOf(".00");
    if (centsIndex != -1) {
        moneyString = moneyString.substring(1, centsIndex);
    }
}
141
duffymo
double amount =200.0;
Locale locale = new Locale("en", "US");      
NumberFormat currencyFormatter = NumberFormat.getCurrencyInstance(locale);
System.out.println(currencyFormatter.format(amount));

ou

double amount =200.0;
System.out.println(NumberFormat.getCurrencyInstance(new Locale("en", "US"))
        .format(amount));

Le meilleur moyen d'afficher de la monnaie 

Sortie

200,00 $

Si vous ne voulez pas utiliser le signe utilisez cette méthode 

double amount = 200;
DecimalFormat twoPlaces = new DecimalFormat("0.00");
System.out.println(twoPlaces.format(amount));

200.00

Cela peut aussi être utilisé (avec le séparateur de mille)

double amount = 2000000;    
System.out.println(String.format("%,.2f", amount));

2 000 000,00

90
Thilina Dharmasena

Je n'ai pas trouvé de bonne solution après la recherche sur Google, il suffit de poster ma solution pour que d'autres puissent s'y référer. utilisez priceToString pour formater de l'argent.

public static String priceWithDecimal (Double price) {
    DecimalFormat formatter = new DecimalFormat("###,###,###.00");
    return formatter.format(price);
}

public static String priceWithoutDecimal (Double price) {
    DecimalFormat formatter = new DecimalFormat("###,###,###.##");
    return formatter.format(price);
}

public static String priceToString(Double price) {
    String toShow = priceWithoutDecimal(price);
    if (toShow.indexOf(".") > 0) {
        return priceWithDecimal(price);
    } else {
        return priceWithoutDecimal(price);
    }
}
16
wu liang

Oui. Vous pouvez utiliser Java.util.formatter . Vous pouvez utiliser une chaîne de formatage telle que "% 10.2f"

6
dj_segfault

J'utilise celui-ci (en utilisant StringUtils de commons-lang):

Double qty = 1.01;
String res = String.format(Locale.GERMANY, "%.2f", qty);
String fmt = StringUtils.removeEnd(res, ",00");

Vous ne devez prendre en charge que les paramètres régionaux et la chaîne correspondante à découper. 

6
Dirk Lachowski

Je pense que c'est simple et clair pour imprimer une devise:

DecimalFormat df = new DecimalFormat("$###,###.##"); // or pattern "###,###.##$"
System.out.println(df.format(12345.678));

rendement: 12 345,68 $

Et une des solutions possibles à la question:

public static void twoDecimalsOrOmit(double d) {
    System.out.println(new DecimalFormat(d%1 == 0 ? "###.##" : "###.00").format(d));
}

twoDecimalsOrOmit((double) 100);
twoDecimalsOrOmit(100.1);

Sortie:

100

100.10

5
Andrey

Je sais que c'est une vieille question mais ...

import Java.text.*;

public class FormatCurrency
{
    public static void main(String[] args)
    {
        double price = 123.4567;
        DecimalFormat df = new DecimalFormat("#.##");
        System.out.print(df.format(price));
    }
}
4
Aezur

vous devriez faire quelque chose comme ça:

public static void main(String[] args) {
    double d1 = 100d;
    double d2 = 100.1d;
    print(d1);
    print(d2);
}

private static void print(double d) {
    String s = null;
    if (Math.round(d) != d) {
        s = String.format("%.2f", d);
    } else {
        s = String.format("%.0f", d);
    }
    System.out.println(s);
}

qui imprime:

100

100,10

4
Stefan De Boey

Nous aurons généralement besoin de faire l’inverse, si votre champ json money est un float, il peut être de 3,1, 3,15 ou 3.

Dans ce cas, vous devrez peut-être l'arrondir pour un affichage correct (et pour pouvoir utiliser un masque sur un champ de saisie ultérieurement):

floatvalue = 200.0; // it may be 200, 200.3 or 200.37, BigDecimal will take care
Locale locale = new Locale("en", "US");      
NumberFormat currencyFormatter = NumberFormat.getCurrencyInstance(locale);

BigDecimal valueAsBD = BigDecimal.valueOf(value);
    valueAsBD.setScale(2, BigDecimal.ROUND_HALF_UP); // add digits to match .00 pattern

System.out.println(currencyFormatter.format(amount));
4
sagits

Vous pouvez simplement faire quelque chose comme ceci et transmettre le nombre entier, puis les centimes après.

String.format("$%,d.%02d",wholeNum,change);
4
user2645904

Je suis d’accord avec @duffymo pour dire que vous devez utiliser les méthodes Java.text.NumberFormat pour ce genre de choses. Vous pouvez réellement effectuer toute la mise en forme de manière native sans faire aucune comparaison de chaînes:

private String formatPrice(final double priceAsDouble) 
{
    NumberFormat formatter = NumberFormat.getCurrencyInstance();
    if (Math.round(priceAsDouble * 100) % 100 == 0) {
        formatter.setMaximumFractionDigits(0);
    }
    return formatter.format(priceAsDouble);
}

Quelques bits à signaler: 

  • L'ensemble Math.round(priceAsDouble * 100) % 100 travaille juste autour des inexactitudes des doubles/floats. Essentiellement, il suffit de vérifier si nous arrondissons à la centaine (il s’agit peut-être d’un parti pris américain). 
  • L'astuce pour supprimer les décimales est la méthode setMaximumFractionDigits()

Quelle que soit votre logique pour déterminer si les décimales doivent être tronquées ou non, setMaximumFractionDigits() doit être utilisé.

4
xbakesx

cette meilleure façon de le faire.

    public static String formatCurrency(String amount) {
        DecimalFormat formatter = new DecimalFormat("###,###,##0.00");
        return formatter.format(Double.parseDouble(amount));
    }

100 -> "100.00"
100.1 -> "100.10"

3
Samet öztoprak

Si vous voulez travailler sur les devises, vous devez utiliser la classe BigDecimal. Le problème est qu’il n’ya aucun moyen de stocker certains nombres flottants en mémoire (par exemple, vous pouvez stocker 5,3456, mais pas 5,3455), ce qui peut avoir des effets sur les mauvais calculs.

Il y a un article de Nice sur la façon de coopérer avec BigDecimal et les monnaies:

http://www.javaworld.com/javaworld/jw-06-2001/jw-0601-cents.html

3
Adrian Adamczyk

Format de 1000000.2 à 1 000 000,20

private static final DecimalFormat DF = new DecimalFormat();

public static String toCurrency(Double d) {
    if (d == null || "".equals(d) || "NaN".equals(d)) {
        return " - ";
    }
    BigDecimal bd = new BigDecimal(d);
    bd = bd.setScale(2, BigDecimal.ROUND_HALF_UP);
    DecimalFormatSymbols symbols = DF.getDecimalFormatSymbols();
    symbols.setGroupingSeparator(' ');
    String ret = DF.format(bd) + "";
    if (ret.indexOf(",") == -1) {
        ret += ",00";
    }
    if (ret.split(",")[1].length() != 2) {
        ret += "0";
    }
    return ret;
}
3
Lukas

Ce post m'a vraiment aidé à obtenir enfin ce que je veux. Donc, je voulais juste contribuer mon code ici pour aider les autres. Voici mon code avec quelques explications.

Le code suivant:

double moneyWithDecimals = 5.50;
double moneyNoDecimals = 5.00;
System.out.println(jeroensFormat(moneyWithDecimals));
System.out.println(jeroensFormat(moneyNoDecimals));

Reviendra:

€ 5,-
€ 5,50

La méthode réelle jeroensFormat ():

public String jeroensFormat(double money)//Wants to receive value of type double
{
        NumberFormat dutchFormat = NumberFormat.getCurrencyInstance();
        money = money;
        String twoDecimals = dutchFormat.format(money); //Format to string
        if(tweeDecimalen.matches(".*[.]...[,]00$")){
            String zeroDecimals = twoDecimals.substring(0, twoDecimals.length() -3);
                return zeroDecimals;
        }
        if(twoDecimals.endsWith(",00")){
            String zeroDecimals = String.format("€ %.0f,-", money);
            return zeroDecimals; //Return with ,00 replaced to ,-
        }
        else{ //If endsWith != ,00 the actual twoDecimals string can be returned
            return twoDecimals;
        }
}

La méthode displayJeroensFormat qui appelle la méthode jeroensFormat () 

    public void displayJeroensFormat()//@parameter double:
    {
        System.out.println(jeroensFormat(10.5)); //Example for two decimals
        System.out.println(jeroensFormat(10.95)); //Example for two decimals
        System.out.println(jeroensFormat(10.00)); //Example for zero decimals
        System.out.println(jeroensFormat(100.000)); //Example for zero decimals
    }

Aura la sortie suivante:

€ 10,50
€ 10,95
€ 10,-
€ 100.000 (In Holland numbers bigger than € 999,- and wit no decimals don't have ,-)

Ce code utilise votre devise actuelle. Dans mon cas, c'est la Hollande, donc la chaîne formatée pour moi sera différente de celle des États-Unis.

  • Hollande: 999.999,99 
  • US: 999.999.99

Il suffit de regarder les 3 derniers caractères de ces chiffres. Mon code a une instruction if pour vérifier si les 3 derniers caractères sont égaux à ", 00". Pour utiliser ceci aux États-Unis, vous devrez peut-être changer cela en ".00" si cela ne fonctionne pas déjà.

2
Jeroen

Voici ce que j'ai fait, en utilisant un entier pour représenter le montant en cents à la place:

public static String format(int moneyInCents) {
    String format;
    Number value;
    if (moneyInCents % 100 == 0) {
        format = "%d";
        value = moneyInCents / 100;
    } else {
        format = "%.2f";
        value = moneyInCents / 100.0;
    }
    return String.format(Locale.US, format, value);
}

Le problème avec NumberFormat.getCurrencyInstance() est que, parfois, vous voulez vraiment que 20 $ soit 20 $, ça a l'air meilleur que 20 $.

Si quelqu'un trouve un meilleur moyen de le faire, en utilisant NumberFormat, je suis tout ouïe.

1
Viktor Nordling

Pour les personnes qui souhaitent formater la devise, mais ne veulent pas qu'elle soit basée sur le local, nous pouvons le faire:

val numberFormat = NumberFormat.getCurrencyInstance() // Default local currency
val currency = Currency.getInstance("USD")            // This make the format not locale specific 
numberFormat.setCurrency(currency)

...use the formator as you want...
0
Haomin
  public static String formatPrice(double value) {
        DecimalFormat formatter;
        if (value<=99999)
          formatter = new DecimalFormat("###,###,##0.00");
        else
            formatter = new DecimalFormat("#,##,##,###.00");

        return formatter.format(value);
    }
0
Prateek Bhardwaj

J'étais assez fou pour écrire ma propre fonction:

Ceci convertira l'entier en format monétaire (peut également être modifié pour les décimales):

 String getCurrencyFormat(int v){
        String toReturn = "";
        String s =  String.valueOf(v);
        int length = s.length();
        for(int i = length; i >0 ; --i){
            toReturn += s.charAt(i - 1);
            if((i - length - 1) % 3 == 0 && i != 1) toReturn += ',';
        }
        return "$" + new StringBuilder(toReturn).reverse().toString();
    }
0
A-Sharabiani