Develop Reference

I want to keep my trailing zeroes when using DecimalFormat

The code below is my attempt to convert my three doubles into a format where they have four decimal places always (because I need to print them with four decimal places for what is meant to be a simple assignment), even if all the numbers after the decimal point in the original double are 0 - as in any whole number. I figured I might be able to use the setMinimumFractionDigits() method to prevent DecimalFormat from eliminating trailing zeroes - but it doesn't do the job: "3.0" still gets printed out instead of what I want: "3.0000". I realise that below my instances of this setMinimumFractionDigits() method are literally doing nothing.
(Numbers whose decimal places aren't all zeroes aren't a problem; the code is working as I want it to for them.)
........ Is there an easy fix? There may be; I don't understand very well the methods I'm using here.
double mean = mean(numbers);
double variance = variance(numbers, mean);
double sd = sd(variance);
DecimalFormat meanFormatted = new DecimalFormat("#.####");
meanFormatted.setMinimumFractionDigits(4);
mean = Double.valueOf(meanFormatted.format(mean));
DecimalFormat varianceFormatted = new DecimalFormat("#.####");
varianceFormatted.setMinimumFractionDigits(4);
variance = Double.valueOf(varianceFormatted.format(variance));
DecimalFormat sdFormatted = new DecimalFormat("#.####");
sdFormatted.setMinimumFractionDigits(4);
sd = Double.valueOf(sdFormatted.format(sd));

see this usage
double d = 12.3;
DecimalFormat meanFormatted = new DecimalFormat("#.0000");
System.out.println (meanFormatted.format (d));

Found a solution:
double mean = mean(numbers);
double variance = variance(numbers, mean);
double sd = sd(variance);
Formatter transform = new Formatter();
Formatter transform1 = new Formatter();
Formatter transform2 = new Formatter();
transform.format("%.4f", mean);
transform1.format("%.4f", variance);
transform2.format("%.4f", sd);
System.out.printf("\nMean = %s\n", transform);
System.out.printf("Variance = %s\n", transform1);
System.out.printf("Standard deviation = %s\n", transform2);

How to always round off upto 2 decimal places in java

I have tried the following code but it is not working in a particular case.
Eg: Suppose, I have a double value=2.5045 and i want it to be rounded off upto two decimal places using the below code.After rounding off, i get the answer as 2.5. But I want the answer to be 2.50 instead. In this case,zero is trimmed off. Is there any way to retain the zero so as to get the desired answer as 2.50 after rounding off.
private static DecimalFormat twoDForm = new DecimalFormat("#.##");
public static double roundTwoDecimals(double amount) {
return Double.valueOf(twoDForm.format(amount));
}

try this pattern
new DecimalFormat("0.00");
but this will change only formatting, double cannot hold number of digits after decimal poin, try BigDecimal
BigDecimal bd = new BigDecimal(2.5045).setScale(2, RoundingMode.HALF_UP);

Look at the documentation for DecimalFormat. For # it says:
Digit, zero shows as absent
0 is probably what you want:
Digit
So what you are looking for is either "0.00" or "#.00" as a format string, depending on whether you want the first digit before the period, to be visible in case the numbers absolute value is smalle than 0.

Try this
DecimalFormat format = new DecimalFormat("#");
format.setMinimumFractionDigits(2);
answer.setText(format.format(data2));

Try This
double d = 4.85999999999;
long l = (int)Math.round(d * 100); // truncates
d = l / 100.0;

You are returning a double. But double or Double are objects representing a number and don't carry any formatting information. Ìf you need to output two decimal places the point to do this is when you convert your double to a String.

use # if you want to ignore 0
new DecimalFormat("###,#0.00").format(d)

There is another way to achieve this . I have already posted answer in post
will just answer again here. As we will require rounding off values many times .
public class RoundingNumbers {
public static void main(String args[]){
double number = 2.5045;
int decimalsToConsider = 2;
BigDecimal bigDecimal = new BigDecimal(number);
BigDecimal roundedWithScale = bigDecimal.setScale(decimalsToConsider, BigDecimal.ROUND_HALF_UP);
System.out.println("Rounded value with setting scale = "+roundedWithScale);
bigDecimal = new BigDecimal(number);
BigDecimal roundedValueWithDivideLogic = bigDecimal.divide(BigDecimal.ONE,decimalsToConsider,BigDecimal.ROUND_HALF_UP);
System.out.println("Rounded value with Dividing by one = "+roundedValueWithDivideLogic);
}
}
Output we will get is
Rounded value with setting scale = 2.50
Rounded value with Dividing by one = 2.50

double kilobytes = 1205.6358;
double newKB = Math.round(kilobytes*100.0)/100.0;
DecimalFormat df = new DecimalFormat("###.##");
System.out.println("kilobytes (DecimalFormat) : " + df.format(kilobytes));
Try this if u are still getting the above problem

Rounding off double value in Java

Currently I'm using DecimalFormat class to round off double value
double d = 42.405;
DecimalFormat f = new DecimalFormat("##.00");
System.out.println(f.format(d));
output: 42.41;
I'm doing browser app testing using Selenium, so based on the browser I need to round off the value.
For Example:
IE rounds off 42.405 to 42.40 and others rounds off to 42.41. But if values are like 42.403, 42.406 then I see consistency across all browsers. So now I have to put a condition in my script so if browser is IE then round off should happen in such a way that I should get 42.40 and for other browsers is should get 42.41. How can i do this?

You can specify the RoundingMode for the DecimalFormatter, but please choose it as per your needs(I've just given an example using HALF_UP).
double d = 42.405;
DecimalFormat f = new DecimalFormat("##.00");
f.setRoundingMode(RoundingMode.HALF_UP);
System.out.println(f.format(d)); // Prints 42.41
Alternatively, you can also use BigDecimal(incase you know why we usually go for BigDecimal instead of double) for the same.
double d = 42.405;
BigDecimal bd = new BigDecimal(d);
bd = bd.setScale(2, RoundingMode.HALF_UP);
System.out.println(bd.doubleValue()); // Prints 42.41

DecimalFormat f=new DecimalFormat("0.00");
String formate = f.format(value);
double finalValue = (Double)f.parse(formate) ;
System.out.println(finalValue);

Use setRoundingMode as:
f.setRoundingMode( RoundingMode.DOWN );
How to round a number to n decimal places in Java

try this may be helpful:
double d = 42.405;
System.out.println(String.format("%2.2f", d));

Also you can do it "handly" as follow
double d = 42.405;
final double roundedValue = (Math.round(d * 100) / (double) 100);
In case of 42.405 you get 42.41 and in case of 42.404 - 42.4
And so after
System.out.println(String.format("%2.2f", roundedValue));
you will get necessary output. 42.41 or 42.40 correspondingly.

Formatting a number with correct decimal scale

I need to format a number with scale of 2 decimal places. The original number may be a whole number or a number with three decimal places. However the result should be formatted to have commas and also two decimal places always regardless of whether the original number is whole number or having decimal places.
When original num = 56565656.342 ==> I need 56,565,656.34
When original num = 56565656 ==> I need 56,565,656.00
When original num = 56565656.7 ==> I need 56,565,656.70
I am using the following code which is formatting the code but its failing to add the two decimal places in the above 2 & 3 cases.
String originalNumber = "56565656.7";
BigDecimal b = new BigDecimal(originalNumber).setScale(2, BigDecimal.ROUND_HALF_UP);
String formattedNumber = NumberFormat.getInstance().format(b);
Please let me know if there is any way to accomplish this in efficeint way.
Thanks in advance.

Take a look at the DecimalFormat class.
Alternatively you can setScale method from the BigDecimal Class.
BigDecimal bg1 = new BigDecimal("56565656.342");
BigDecimal bg2 = new BigDecimal("56565656.00");
BigDecimal bg3 = new BigDecimal("56565656.70");
DecimalFormat df = new DecimalFormat("###,###.00");
System.out.println(df.format(bg1.doubleValue()));
System.out.println(df.format(bg2.doubleValue()));
System.out.println(df.format(bg3.doubleValue()));
System.out.println(bg1.setScale(2, BigDecimal.ROUND_HALF_UP));
System.out.println(bg2.setScale(2, BigDecimal.ROUND_HALF_UP));
System.out.println(bg3.setScale(2, BigDecimal.ROUND_HALF_UP));
Yields:
56,565,656.34
56,565,656.00
56,565,656.70
56565656.34
56565656.00
56565656.70
EDIT: Also forgot to mention: If you are after precision, I would recommend you use the setScale method, using the .doubleValue() method will yield a double which can cause loss of precision.

Just use NumberFormat and specify the fraction digits, and rounding method, to print :
String [] originalNumbers = new String[] {
"56565656.342",
"56565656.7",
"56565656"
};
NumberFormat df = NumberFormat.getInstance();
df.setMinimumFractionDigits(2);
df.setMaximumFractionDigits(2);
df.setRoundingMode(RoundingMode.HALF_UP);
for (String number : originalNumbers) {
String formattedNumber = df.format(new BigDecimal(number));
System.out.println(formattedNumber);
}
Will print
56,565,656.34
56,565,656.70
56,565,656.00
** Edit **
DecimalFormat df = new DecimalFormat("#,###.00");
Will produce the exact same result with the given code above.

DecimalFormat class would do it for you.... You will have to specify appropriate format.

DecimalFormat, how to set maximum number of integer digits via patern?

I want to format a number using DecimalFormat.
The maximum number of integer (and fractional) digits must be 2.
If the number is 345561.7301 the desired result would be: 61.73
This is my code:
double number = 345561.7301;
DecimalFormat formater =
(DecimalFormat)DecimalFormat.getInstance(Locale.US);//This locale only
formater.applyPattern("00.00");
System.out.println(formater.format(number));
I do not want to use setMaximumIntegerDigits() method.

What about just using substring?
double number = 345561.7301;
DecimalFormat formater =
(DecimalFormat)DecimalFormat.getInstance(Locale.US); //This locale only
formater.applyPattern("00.00");
//formater.setMaximumIntegerDigits(2); // <- don't want to use this
String tmp = formater.format(number);
System.out.println(tmp.substring(tmp.length() - 5));

Using a pattern might not be the best option in this scenario. I would reccommend using modulus division '%' and get the remainder of number/100.
double number = 345561.7301 % 100;
DecimalFormat formater = (DecimalFormat)DecimalFormat.getInstance(Locale.US);
formater.applyPattern("00.00");
System.out.println(formater.format(number));