We Keep Coding

Is it normal that is not rounding while parsing? NumberFormat

Why does it not round in the parsing process?
NumberFormat format = NumberFormat.getInstance();
System.out.println(format.getMaximumFractionDigits());// 3
System.out.println(format.getRoundingMode());// half even
Double dob = (Double)format.parse("1212.35656");
System.out.println(dob);// output is 1212.35656

The digit counts are only used for formatting. When you parse a number you always get the number that best matches the input, even if it has more digits than the NumberFormat would use to format.
To parse a number from a string and then round to a given number of fractional digits you can use BigDecimal from the java.math package:
BigDecimal bd = BigDecimal("1212.35656");
double dob = bd.setScale(3, RoundingMode.HALF_EVEN).doubleValue();

To obtain what you desire you need to call the formatter metod of the implementation NumberFormat loaded (in your case DecimalFromat); i just added the needed lines at the end and wrapped in a main:
import java.text.NumberFormat;
public class NumberFormatRounding {
public static void main(String[] args) throws Exception{
NumberFormat formatter = NumberFormat.getInstance();
System.out.println(formatter.getMaximumFractionDigits());// 3
System.out.println(formatter.getRoundingMode());// half even
Double dob = (Double) formatter.parse("1212.35656");
System.out.println(dob);// output is 1212.35656
String formattedDob = formatter.format(dob.doubleValue());
System.out.println(formattedDob);// output is 1212.357
}
}
Note that the formattedDob is a String

Java: double: how to ALWAYS show two decimal digits

I use double values in my project and I would like to always show the first two decimal digits, even if them are zeros. I use this function for rounding and if the value I print is 3.47233322 it (correctly) prints 3.47. But when I print, for example, the value 2 it prints 2.0.
public static double round(double d) {
BigDecimal bd = new BigDecimal(d);
bd = bd.setScale(2, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();
}
I want to print 2.00!
Is there a way to do this without using Strings?
EDIT: from your answers (which I thank you for) I understand that I wasn't clear in telling what I am searching (and I'm sorry for this): I know how to print two digits after the number using the solutions you proposed... what i want is to store in the double value directly the two digits! So that when I do something like this System.out.println("" + d) (where d is my double with value 2) it prints 2.00.
I'm starting to think that there is no way to do this... right? Thank you again anyway for your answers, please let me know if you know a solution!

You can use something like this:
double d = 1.234567;
DecimalFormat df = new DecimalFormat("#.00");
System.out.print(df.format(d));
Edited to actually answer the question because I needed the real answer and this came up on google and someone marked it as the answer despite the fact that this wasn't going to work when the decimals were 0.

Use the java.text.NumberFormat for this:
NumberFormat nf= NumberFormat.getInstance();
nf.setMaximumFractionDigits(2);
nf.setMinimumFractionDigits(2);
nf.setRoundingMode(RoundingMode.HALF_UP);
System.out.print(nf.format(decimalNumber));

You can simply do this:
double d = yourDoubleValue;
String formattedData = String.format("%.02f", d);

DecimalFormat is the easiest option to use:
double roundTwoDecimals(double d) {
DecimalFormat twoDecimals = new DecimalFormat("#.##");
return Double.valueOf(twoDecimals.format(d));
}
Hope this solves your issue...

java.text.DecimalFormat df = new java.text.DecimalFormat("###,###.##");
df.setMaximumFractionDigits(2);
df.setMinimumFractionDigits(2);

You can use something like this:
If you want to retain 0 also in the answer:
then use (0.00) in the format String
double d = 2.46327;
DecimalFormat df = new DecimalFormat("0.00");
System.out.print(df.format(d));
The output: 2.46
double d = 0.0001;
DecimalFormat df = new DecimalFormat("0.00");
System.out.print(df.format(d));
The output: 0.00
However, if you use DecimalFormat df = new DecimalFormat("0.##");
double d = 2.46327;
DecimalFormat df = new DecimalFormat("0.##");
System.out.print(df.format(d));
The output: 2.46
double d = 0.0001;
DecimalFormat df = new DecimalFormat("0.##");
System.out.print(df.format(d));
The output: 0

I would just use something like:
System.out.printf("%.2f", theValueYouWantToPrint);
This gives you two decimals.

Double decimal formatting in Java

I'm having some problems formatting the decimals of a double. If I have a double value, e.g. 4.0, how do I format the decimals so that it's 4.00 instead?

One of the way would be using NumberFormat.
NumberFormat formatter = new DecimalFormat("#0.00");
System.out.println(formatter.format(4.0));
Output:
4.00

With Java 8, you can use format method..: -
System.out.format("%.2f", 4.0); // OR
System.out.printf("%.2f", 4.0);
f is used for floating point value..
2 after decimal denotes, number of decimal places after .
For most Java versions, you can use DecimalFormat: -
DecimalFormat formatter = new DecimalFormat("#0.00");
double d = 4.0;
System.out.println(formatter.format(d));

Use String.format:
String.format("%.2f", 4.52135);
As per docs:
The locale always used is the one returned by Locale.getDefault().

Using String.format, you can do this:
double price = 52000;
String.format("$%,.2f", price);
Notice the comma which makes this different from #Vincent's answer
Output:
$52,000.00
A good resource for formatting is the official java page on the subject

You could always use the static method printf from System.out - you'd then implement the corresponding formatter; this saves heap space in which other examples required you to do.
Ex:
System.out.format("%.4f %n", 4.0);
System.out.printf("%.2f %n", 4.0);
Saves heap space which is a pretty big bonus, nonetheless I hold the opinion that this example is much more manageable than any other answer, especially since most programmers know the printf function from C (Java changes the function/method slightly though).

double d = 4.0;
DecimalFormat nf = DecimalFormat.getInstance(Locale.ENGLISH);
System.out.println(nf.format("#.##"));

You can use any one of the below methods
If you are using java.text.DecimalFormat
DecimalFormat decimalFormat = NumberFormat.getCurrencyInstance();
decimalFormat.setMinimumFractionDigits(2);
System.out.println(decimalFormat.format(4.0));
OR
DecimalFormat decimalFormat = new DecimalFormat("#0.00");
System.out.println(decimalFormat.format(4.0));
If you want to convert it into simple string format
System.out.println(String.format("%.2f", 4.0));
All the above code will print 4.00

new DecimalFormat("#0.00").format(4.0d);

An alternative method is use the setMinimumFractionDigits method from the NumberFormat class.
Here you basically specify how many numbers you want to appear after the decimal point.
So an input of 4.0 would produce 4.00, assuming your specified amount was 2.
But, if your Double input contains more than the amount specified, it will take the minimum amount specified, then add one more digit rounded up/down
For example, 4.15465454 with a minimum amount of 2 specified will produce 4.155
NumberFormat nf = NumberFormat.getInstance();
nf.setMinimumFractionDigits(2);
Double myVal = 4.15465454;
System.out.println(nf.format(myVal));
Try it online

There are many way you can do this. Those are given bellow:
Suppose your original number is given bellow:
double number = 2354548.235;
Using NumberFormat:
NumberFormat formatter = new DecimalFormat("#0.00");
System.out.println(formatter.format(number));
Using String.format:
System.out.println(String.format("%,.2f", number));
Using DecimalFormat and pattern:
NumberFormat nf = DecimalFormat.getInstance(Locale.ENGLISH);
DecimalFormat decimalFormatter = (DecimalFormat) nf;
decimalFormatter.applyPattern("#,###,###.##");
String fString = decimalFormatter.format(number);
System.out.println(fString);
Using DecimalFormat and pattern
DecimalFormat decimalFormat = new DecimalFormat("############.##");
BigDecimal formattedOutput = new BigDecimal(decimalFormat.format(number));
System.out.println(formattedOutput);
In all cases the output will be:
2354548.23
Note:
During rounding you can add RoundingMode in your formatter. Here are some rounding mode given bellow:
decimalFormat.setRoundingMode(RoundingMode.CEILING);
decimalFormat.setRoundingMode(RoundingMode.FLOOR);
decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN);
decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
decimalFormat.setRoundingMode(RoundingMode.UP);
Here are the imports:
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.Locale;

Works 100%.
import java.text.DecimalFormat;
public class Formatting {
public static void main(String[] args) {
double value = 22.2323242434342;
// or value = Math.round(value*100) / 100.0;
System.out.println("this is before formatting: "+value);
DecimalFormat df = new DecimalFormat("####0.00");
System.out.println("Value: " + df.format(value));
}
}

First import NumberFormat. Then add this:
NumberFormat currencyFormatter = NumberFormat.getCurrencyInstance();
This will give you two decimal places and put a dollar sign if it's dealing with currency.
import java.text.NumberFormat;
public class Payroll
{
/**
* #param args the command line arguments
*/
public static void main(String[] args)
{
int hoursWorked = 80;
double hourlyPay = 15.52;
double grossPay = hoursWorked * hourlyPay;
NumberFormat currencyFormatter = NumberFormat.getCurrencyInstance();
System.out.println("Your gross pay is " + currencyFormatter.format(grossPay));
}
}

You can do it as follows:
double d = 4.0;
DecimalFormat df = new DecimalFormat("#.##");
System.out.print(df.format(d));

I know that this is an old topic, but If you really like to have the period instead of the comma, just save your result as X,00 into a String and then just simply change it for a period so you get the X.00
The simplest way is just to use replace.
String var = "X,00";
String newVar = var.replace(",",".");
The output will be the X.00 you wanted. Also to make it easy you can do it all at one and save it into a double variable:
Double var = Double.parseDouble(("X,00").replace(",",".");
I know that this reply is not useful right now but maybe someone that checks this forum will be looking for a quick solution like this.

how to Convert double's exponetial form to normal decimal form

All Experts
I am doing some logical stuff in my program with an variable of type double.
everything is Ok when the value of type double parameter is less then 1,00,00,000.
But when the value of it becomes > one Crores it is automatically converted in to an exponetial form and i got an exception .
For Example
Value 10010001.25 becomes
1.001000125E7
I want the value is in normal form .
Any help ??
Thank You
Mihir Parekh

I would recommend using System.out.println(new BigDecimal(d)).
Here is a comparison of some alternatives:
import java.math.BigDecimal;
import java.text.DecimalFormat;
public class Test {
public static void main(String[] args) {
double d = 10010001.125;
// 10010001.125000 (lots of trailing zeroes)
System.out.printf("%f%n", d);
// 10010001.13 (perhaps not what you want)
System.out.printf("%.2f%n", d);
// 10010001.12 (not accurate in my opinion)
DecimalFormat df = new DecimalFormat("#.##");
System.out.println(df.format(d));
// 10010001.125 (all relevant digits, and no trailing zeroes)
System.out.println(new BigDecimal(d));
}
}

The double is a binary format. The two formats you see are different ways of converting a double into a String. You can try DecimalFormat to convert a number into a decimal formatted String.
However you might find this simpler
double d = 10010001.25;
System.out.printf("%.2f%n", d);
prints
10010001.25
EDIT:
System.out.printf("%,.2f%n", d);
prints
10,010,001.25

You can use DecimalFormat
double d = 10010001.25;
DecimalFormat df = new DecimalFormat("#.##");
System.out.print(df.format(d));

How to use Java's DecimalFormat for "smart" currency formatting?

I'd like to use Java's DecimalFormat to format doubles like so:
#1 - 100 -> $100
#2 - 100.5 -> $100.50
#3 - 100.41 -> $100.41
The best I can come up with so far is:
new DecimalFormat("'$'0.##");
But this doesn't work for case #2, and instead outputs "$100.5"
Edit:
A lot of these answers are only considering cases #2 and #3 and not realizing that their solution will cause #1 to format 100 as "$100.00" instead of just "$100".

Does it have to use DecimalFormat?
If not, it looks like the following should work:
String currencyString = NumberFormat.getCurrencyInstance().format(currencyNumber);
//Handle the weird exception of formatting whole dollar amounts with no decimal
currencyString = currencyString.replaceAll("\\.00", "");

Use NumberFormat:
NumberFormat n = NumberFormat.getCurrencyInstance(Locale.US);
double doublePayment = 100.13;
String s = n.format(doublePayment);
System.out.println(s);
Also, don't use doubles to represent exact values. If you're using currency values in something like a Monte Carlo method (where the values aren't exact anyways), double is preferred.
See also: Write Java programs to calculate and format currency

Try
new DecimalFormat("'$'0.00");
Edit:
I Tried
DecimalFormat d = new DecimalFormat("'$'0.00");
System.out.println(d.format(100));
System.out.println(d.format(100.5));
System.out.println(d.format(100.41));
and got
$100.00
$100.50
$100.41

Try using
DecimalFormat.setMinimumFractionDigits(2);
DecimalFormat.setMaximumFractionDigits(2);

You can check "is number whole or not" and choose needed number format.
public class test {
public static void main(String[] args){
System.out.println(function(100d));
System.out.println(function(100.5d));
System.out.println(function(100.42d));
}
public static String function(Double doubleValue){
boolean isWholeNumber=(doubleValue == Math.round(doubleValue));
DecimalFormatSymbols formatSymbols = new DecimalFormatSymbols(Locale.GERMAN);
formatSymbols.setDecimalSeparator('.');
String pattern= isWholeNumber ? "#.##" : "#.00";
DecimalFormat df = new DecimalFormat(pattern, formatSymbols);
return df.format(doubleValue);
}
}
will give exactly what you want:
100
100.50
100.42

You can use the following format:
DecimalFormat dformat = new DecimalFormat("$#.##");

I know its too late. However following worked for me :
DecimalFormatSymbols otherSymbols = new DecimalFormatSymbols(Locale.UK);
new DecimalFormat("\u00A4#######0.00",otherSymbols).format(totalSale);
\u00A4 : acts as a placeholder for currency symbol
#######0.00 : acts as a placeholder pattern for actual number with 2 decimal
places precision.
Hope this helps whoever reads this in future :)

You can try by using two different DecimalFormat objects based on the condition as follows:
double d=100;
double d2=100.5;
double d3=100.41;
DecimalFormat df=new DecimalFormat("'$'0.00");
if(d%1==0){ // this is to check a whole number
DecimalFormat df2=new DecimalFormat("'$'");
System.out.println(df2.format(d));
}
System.out.println(df.format(d2));
System.out.println(df.format(d3));
Output:-
$100
$100.50
$100.41

You could use the Java Money API to achieve this. (although this is not using DecialFormat)
long amountInCents = ...;
double amountInEuro = amountInCents / 100.00;
String customPattern;
if (minimumOrderValueInCents % 100 == 0) {
customPattern = "# ¤";
} else {
customPattern = "#.## ¤";
}
Money minDeliveryAmount = Money.of(amountInEuro, "EUR");
MonetaryAmountFormat formatter = MonetaryFormats.getAmountFormat(AmountFormatQueryBuilder.of(Locale.GERMANY)
.set(CurrencyStyle.SYMBOL)
.set("pattern", customPattern)
.build());
System.out.println(minDeliveryAmount);

printf also works.
Example:
double anyNumber = 100;
printf("The value is %4.2f ", anyNumber);
Output:
The value is 100.00
4.2 means force the number to have two digits after the decimal. The 4 controls how many digits to the right of the decimal.