number - Formato de número de moneda de Java

numberformat java example

Question

¿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.

Answer 1

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

Answer 2

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.

Answer 3

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

Answer 4

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.

Answer 5

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() .

Answer 6

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.

Answer 7

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

Answer 8

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

Answer 9

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

Answer 10

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

Answer 11

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

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

Answer 12

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

Answer 13

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

Answer 14

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

Answer 15

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

Answer 16

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

Answer 17

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"

Answer 18

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