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.
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
}
}
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);
}
}
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
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);
}
}
Oui. Vous pouvez utiliser Java.util.formatter . Vous pouvez utiliser une chaîne de formatage telle que "% 10.2f"
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.
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
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));
}
}
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
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));
Vous pouvez simplement faire quelque chose comme ceci et transmettre le nombre entier, puis les centimes après.
String.format("$%,d.%02d",wholeNum,change);
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:
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). setMaximumFractionDigits()
Quelle que soit votre logique pour déterminer si les décimales doivent être tronquées ou non, setMaximumFractionDigits()
doit être utilisé.
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"
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
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;
}
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.
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à.
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.
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...
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);
}
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();
}