Format du numéro de devise Java

Existe-t-il un moyen de formater un nombre décimal 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.

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

    Si vous souhaitez le formater de cette façon, vous devez définir un epsilon, c’est-à-dire une distance maximale par rapport à un nombre entier, et utiliser un format d’entier si la différence est plus petite et un flottant sinon.

    Quelque chose comme ça ferait l’affaire:

     public Ssortingng 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 } } 

    Je recommande d’utiliser le package java.text:

     double money = 100.1; NumberFormat formatter = NumberFormat.getCurrencyInstance(); Ssortingng moneySsortingng = formatter.format(money); System.out.println(moneySsortingng); 

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

    Mais si vous devez, tronquez la chaîne que vous recevez si c’est un dollar entier:

     if (moneySsortingng.endsWith(".00")) { int centsIndex = moneySsortingng.lastIndexOf(".00"); if (centsIndex != -1) { moneySsortingng = moneySsortingng.subssortingng(1, centsIndex); } } 
     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)); 

    La meilleure façon d’afficher la devise

    Sortie

    200,00 $

    Si vous ne voulez pas utiliser de 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 milliers)

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

    2,000,000.00

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

     public static Ssortingng priceWithDecimal (Double price) { DecimalFormat formatter = new DecimalFormat("###,###,###.00"); return formatter.format(price); } public static Ssortingng priceWithoutDecimal (Double price) { DecimalFormat formatter = new DecimalFormat("###,###,###.##"); return formatter.format(price); } public static Ssortingng priceToSsortingng(Double price) { Ssortingng toShow = priceWithoutDecimal(price); if (toShow.indexOf(".") > 0) { return priceWithDecimal(price); } else { return priceWithoutDecimal(price); } } 

    Oui. Vous pouvez utiliser java.util.formatter . Vous pouvez utiliser une chaîne de formatage comme “% 10.2f”

    J’utilise celui-ci (en utilisant SsortingngUtils de commons-lang):

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

    Vous ne devez vous occuper que des parameters régionaux et de la chaîne correspondante.

    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)); 

    sortie: 12 345,68 $

    Et l’une des solutions possibles pour 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

    vous devriez faire quelque chose comme ceci:

     public static void main(Ssortingng[] args) { double d1 = 100d; double d2 = 100.1d; print(d1); print(d2); } private static void print(double d) { Ssortingng s = null; if (Math.round(d) != d) { s = Ssortingng.format("%.2f", d); } else { s = Ssortingng.format("%.0f", d); } System.out.println(s); } 

    qui imprime:

    100

    100,10

    Je sais que c’est une vieille question mais …

     import java.text.*; public class FormatCurrency { public static void main(Ssortingng[] args) { double price = 123.4567; DecimalFormat df = new DecimalFormat("#.##"); System.out.print(df.format(price)); } } 

    Vous pouvez simplement faire quelque chose comme ça et passer le nombre entier et ensuite les centimes après.

     Ssortingng.format("$%,d.%02d",wholeNum,change); 

    Je suis d’accord avec @duffymo que vous devez utiliser les méthodes java.text.NumberFormat pour ce genre de choses. Vous pouvez réellement faire tout le formatage en natif sans faire de comparaison entre les chaînes:

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

    Quelques bits à souligner:

    • L’ensemble Math.round(priceAsDouble * 100) % 100 fait que contourner les inexactitudes des doubles / flottants. Fondamentalement, il suffit de vérifier si nous arrondissons à la centaine (peut-être que c’est 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é.

    Nous devrons généralement faire l’inverse, si votre champ d’argent json est un flottant, il peut s’agir de 3.1, 3.15 ou juste 3.

    Dans ce cas, vous devrez peut-être arrondir l’affichage (et 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)); 

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

    Il y a un bon article sur la coopération avec BigDecimal et les devises:

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

    Format de 1000000.2 à 1 000 000,20

     private static final DecimalFormat DF = new DecimalFormat(); public static Ssortingng 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(' '); Ssortingng ret = DF.format(bd) + ""; if (ret.indexOf(",") == -1) { ret += ",00"; } if (ret.split(",")[1].length() != 2) { ret += "0"; } return ret; } 

    cette meilleure façon de le faire.

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

    100 -> “100.00”
    100.1 -> “100.10”

    Ce post m’a vraiment aidé à enfin obtenir ce que je voulais. Je voulais juste apporter 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 actuelle jeroensFormat ():

     public Ssortingng jeroensFormat(double money)//Wants to receive value of type double { NumberFormat dutchFormat = NumberFormat.getCurrencyInstance(); money = money; Ssortingng twoDecimals = dutchFormat.format(money); //Format to ssortingng if(tweeDecimalen.matches(".*[.]...[,]00$")){ Ssortingng zeroDecimals = twoDecimals.subssortingng(0, twoDecimals.length() -3); return zeroDecimals; } if(twoDecimals.endsWith(",00")){ Ssortingng zeroDecimals = Ssortingng.format("€ %.0f,-", money); return zeroDecimals; //Return with ,00 replaced to ,- } else{ //If endsWith != ,00 the actual twoDecimals ssortingng 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

    Regardez simplement 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 l’utiliser aux États-Unis, vous devrez peut-être changer cela en “.00” si cela ne fonctionne pas déjà.

    C’est ce que j’ai fait, en utilisant un entier pour représenter la quantité en cents à la place:

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

    Le problème avec NumberFormat.getCurrencyInstance() est que parfois vous voulez vraiment que 20 $ soit 20 $, cela semble juste mieux que 20,00 $.

    Si quelqu’un trouve une meilleure façon de le faire, en utilisant NumberFormat, je suis tout à fait prêt.

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

    Cela convertira un entier en un format de devise (peut également être modifié pour les décimales):

      Ssortingng getCurrencyFormat(int v){ Ssortingng toReturn = ""; Ssortingng s = Ssortingng.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 SsortingngBuilder(toReturn).reverse().toSsortingng(); }