Formato de número de moneda de Java

¿Hay alguna forma de formatear un decimal de la siguiente manera?

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

Si es un número redondo, omita la parte decimal. De lo contrario, formatee con dos decimales.

Lo dudo. El problema es que 100 nunca es 100 si es un flotador, normalmente es 99.9999999999 o 100.0000001 o algo así.

Si desea formatearlo de esa manera, debe definir un épsilon, es decir, una distancia máxima desde un número entero, y usar el formato entero si la diferencia es más pequeña, y un flotante en caso contrario.

Algo como esto haría el truco:

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

Recomiendo usar el paquete java.text:

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

Esto tiene el beneficio adicional de ser específico de la configuración regional.

Pero, si debe hacerlo, trunque la Cadena que obtiene si es un dólar entero:

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

o

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

La mejor forma de mostrar moneda

Salida

$ 200.00

Si no quieres usar el signo usa este método

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

200.00

Esto también se puede usar (con el separador de mil)

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

2,000,000.00

No encontré ninguna buena solución después de la búsqueda de Google, solo publico mi solución para que otros hagan referencia. use priceToString para formatear el dinero.

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

Sí. Puedes usar java.util.formatter . Puede usar una cadena de formato como “% 10.2f”

Estoy usando este (usando StringUtils de commons-lang):

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

Solo debe ocuparse de la configuración regional y la cadena correspondiente para cortar.

Creo que esto es simple y claro para imprimir una moneda:

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

salida: $ 12,345.68

Y una de las posibles soluciones para la pregunta:

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

Salida:

100

100.10

deberías hacer algo como esto:

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

que imprime:

100

100,10

Sé que esta es una vieja pregunta, pero …

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

Puedes hacer algo como esto y pasar el número completo y luego los centavos posteriores.

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

Estoy de acuerdo con @duffymo en que necesitas usar los métodos java.text.NumberFormat para este tipo de cosas. En realidad, puedes hacer todo el formateo de forma nativa en él sin hacer ningún String que te compare:

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

Un par de bits para señalar:

  • Math.round(priceAsDouble * 100) % 100 completo Math.round(priceAsDouble * 100) % 100 solo está trabajando en torno a las imprecisiones de dobles / flotantes. Básicamente, solo comprobamos si redondeamos al lugar de las centenas (quizás esto sea un sesgo de EE. UU.) ¿Quedan centavos restantes?
  • El truco para eliminar los decimales es el método setMaximumFractionDigits()

Cualquiera que sea su lógica para determinar si los decimales deben truncarse o no, se debe usar setMaximumFractionDigits() .

Por lo general, tendremos que hacer la inversión, si su campo de dinero json es un flotante, puede venir como 3.1, 3.15 o simplemente 3.

En este caso, es posible que deba redondearlo para que se muestre correctamente (y para poder usar una máscara en un campo de entrada más adelante):

 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 desea trabajar en monedas, debe usar la clase BigDecimal. El problema es que no hay forma de almacenar algunos números flotantes en la memoria (por ejemplo, puedes almacenar 5.3456, pero no 5.3455), lo que puede tener efectos en los cálculos incorrectos.

Hay un buen artículo sobre cómo cooperar con BigDecimal y monedas:

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

Formato de 1000000.2 a 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; } 

esta es la mejor forma de hacerlo.

  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”

Esta publicación realmente me ayudó a obtener finalmente lo que quiero. Así que solo quería contribuir con mi código aquí para ayudar a otros. Aquí está mi código con alguna explicación.

El siguiente código:

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

Regresará:

 € 5,- € 5,50 

El método actual 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; } } 

El método muestra JeroensFormat que llama al método 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 } 

Tendrá la siguiente salida:

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

Este código usa tu moneda actual. En mi caso, eso es Holanda, así que la secuencia formateada para mí será diferente a la de alguien en los EE. UU.

  • Holanda: 999.999,99
  • EE. UU .: 999,999.99

Solo mira los últimos 3 caracteres de esos números. Mi código tiene una instrucción if para verificar si los últimos 3 caracteres son iguales a “, 00”. Para usar esto en los EE. UU., Puede que tenga que cambiar eso a “.00” si aún no funciona.

Esto es lo que hice, usando un número entero para representar la cantidad como centavos en su lugar:

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

El problema con NumberFormat.getCurrencyInstance() es que a veces realmente quieres que $ 20 sean $ 20, se ve mejor que $ 20.00.

Si alguien encuentra una mejor manera de hacerlo, usando NumberFormat, soy todo oídos.

Estaba lo suficientemente loco como para escribir mi propia función:

Esto convertirá el número entero en formato de moneda (también se puede modificar para decimales):

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