Format liczb waluty Java

Czy istnieje sposób na sformatowanie ułamka dziesiętnego w następujący sposób:

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

Jeśli jest to liczba okrągła, pomiń część dziesiętną. W przeciwnym razie format z dwoma miejscami po przecinku.

Wątpię. Problem polega na tym, że 100 nigdy nie jest 100, jeśli jest to liczba zmiennoprzecinkowa, zwykle jest to 99,99999999999 lub 100,0000001 lub coś w tym rodzaju.

Jeśli chcesz sformatować to w ten sposób, musisz zdefiniować epsilon, czyli maksymalną odległość od liczby całkowitej i użyć formatowania liczb całkowitych, jeśli różnica jest mniejsza, i zmiennoprzecinkowej w przeciwnym razie.

Coś takiego załatwiłoby sprawę:

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

Polecam użycie pakietu java.text:

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

Ma to tę dodatkową zaletę, że jest specyficzna dla lokalizacji.

Ale jeśli musisz, skróć ciąg, który otrzymujesz, jeśli jest to cały dolar:

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

lub

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

Najlepszy sposób na wyświetlanie waluty

Wynik

200,00 $

Jeśli nie chcesz używać znaku, użyj tej metody

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

200,00

Można tego również użyć (z separatorem tysięcy)

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

2 000 000,00

Nie znalazłem żadnego dobrego rozwiązania po wyszukiwaniu w Google, po prostu opublikuj moje rozwiązanie, aby inni mogli się z nimi zapoznać. użyj priceToString do formatowania pieniędzy.

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

Tak. Możesz użyć java.util.formatter . Możesz użyć ciągu formatującego, takiego jak „% 10.2f”

Używam tego (używam StringUtils z commons-lang):

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

Musisz tylko zadbać o lokalizację i odpowiedni ciąg do cięcia.

Myślę, że jest to proste i jasne w przypadku drukowania waluty:

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

wyjście: 12 345,68 $

I jedno z możliwych rozwiązań na pytanie:

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

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

Wynik:

100

100.10

Zwykle będziemy musieli zrobić odwrotność, jeśli twoje pole pieniężne json jest zmiennoprzecinkowe, może mieć wartość 3,1, 3,15 lub tylko 3.

W takim przypadku może być konieczne zaokrąglenie go, aby poprawnie wyświetlić (i móc później użyć maski w polu wprowadzania):

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

w ten najlepszy sposób.

    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”

NumberFormat currency = NumberFormat.getCurrencyInstance();
String myCurrency = currency.format(123.5);
System.out.println(myCurrency);

wynik:

$123.50

Jeśli chcesz zmienić walutę,

NumberFormat currency = NumberFormat.getCurrencyInstance(Locale.CHINA);
String myCurrency = currency.format(123.5);
System.out.println(myCurrency);

wynik:

￥123.50

powinieneś zrobić coś takiego:

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

który drukuje:

100

100,10

Wiem, że to stare pytanie, ale ...

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

Możesz po prostu zrobić coś takiego i podać całą liczbę, a następnie centy.

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

Zgadzam się z @duffymo, że musisz używać java.text.NumberFormatmetod do tego typu rzeczy. W rzeczywistości możesz wykonać całe formatowanie w nim natywnie bez wykonywania jakichkolwiek porównań typu String:

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

Kilka bitów, na które warto zwrócić uwagę:

• Całość Math.round(priceAsDouble * 100) % 100po prostu omija niedokładności podwójnych / floatów. Po prostu sprawdzając, czy zaokrąglijmy do setek (może to nastawienie amerykańskie), czy są jeszcze centy.
• Sztuczka setMaximumFractionDigits()polegająca na usunięciu liczb dziesiętnych polega na metodzie

Bez względu na logikę określania, czy ułamki dziesiętne powinny zostać obcięte, czy też nie, setMaximumFractionDigits()powinna zostać wykorzystana.

Jeśli chcesz pracować na walutach, musisz użyć klasy BigDecimal. Problem polega na tym, że nie ma sposobu na przechowywanie w pamięci niektórych liczb zmiennoprzecinkowych (np. Można zapisać 5,3456, ale nie 5,3455), co może mieć wpływ na złe obliczenia.

Jest fajny artykuł, jak współpracować z BigDecimal i walutami:

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

Format od 1000000,2 do 1000000,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;
}

Ten post naprawdę pomógł mi w końcu dostać to, czego chcę. Więc chciałem po prostu dodać tutaj swój kod, aby pomóc innym. Oto mój kod z pewnym wyjaśnieniem.

Poniższy kod:

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

Wróci:

€ 5,-
€ 5,50

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

Metoda displayJeroensFormat, która wywołuje metodę 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
    }

Będzie miał następujący wynik:

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

Ten kod wykorzystuje Twoją aktualną walutę. W moim przypadku jest to Holandia, więc sformatowany ciąg dla mnie będzie inny niż dla kogoś w USA.

• Holandia: 999,999,99
• USA: 999 999,99

Po prostu obserwuj ostatnie 3 znaki tych liczb. Mój kod zawiera instrukcję if, która sprawdza, czy ostatnie 3 znaki są równe „, 00”. Aby używać tego w USA, być może trzeba będzie zmienić to na „.00”, jeśli to jeszcze nie działa.

Byłem na tyle szalony, żeby napisać własną funkcję:

Spowoduje to konwersję liczby całkowitej na format walutowy (można go również zmodyfikować w przypadku liczb dziesiętnych):

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

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

Oto, co zrobiłem, używając liczby całkowitej do przedstawienia kwoty w centach:

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

Problem NumberFormat.getCurrencyInstance()polega na tym, że czasami naprawdę chcesz, aby 20 $ to 20 $, po prostu wygląda lepiej niż 20,00 $.

Jeśli ktoś znajdzie lepszy sposób na zrobienie tego, używając NumberFormat, mam uszy.

Dla osób, które chcą sformatować walutę, ale nie chcą, aby była oparta na lokalnej, możemy to zrobić:

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