You can use String.format("%.2f", d), your double will be rounded automatically.

Remember you can't use

 String.format("%.2f", maltRequiredString);

Because maltRequiredString is string. Correct coding is that you must use float in this function and for that you have to convert your string to float

float f = Float.valueOf(maltRequiredString);  
String test = String.format("%.02f", f);

You can also use this technique for making it 2 decimal

DecimalFormat decimalFormat = new DecimalFormat("#.##");
float twoDigitsF = Float.valueOf(decimalFormat.format(f));

yourTextView.setText(String.format("Value of a: %.2f", a));

DecimalFormat uses String (thus allocates additional memory), a big overhead compared to

(float)Math.round(value * 100) / 100

Have you tried this:

DecimalFormat sf = new DecimalFormat("00.000000");
String s = sf.format(5.494394);
System.out.println(s); //prints 05.494394

EDIT

Based on your new question, why don't you do this:

double latitude = location.getLatitude();
double longitude = location.getLongitude();
GeoPoint ourLocation = new GeoPoint((int) (latitude * 1E6), (int) (longitude * 1E6));
//....
System.out.println("Lat is  " + latitude);
System.out.println("Longi is  " + longitude);

1.2975118E7 is scientific notation.

1.2975118E7 = 1.2975118 * 10^7 = 12975118

Also, Math.round(f) returns an integer. You can't use it to get your desired format x.xx.

You could use String.format.

String s = String.format("%.2f", 1.2975118);
// 1.30

If you want to round up you can use this method

cantDecimal = 2; number = 164.9835

public static double aroundUp(double number, int canDecimal) {
    int cifras = (int) Math.pow(10, canDecimal);
    return Math.ceil(number * cifras) / cifras;
}

return = 164.99

Extra: Ceil Method in Math. The method ceil gives the smallest integer that is greater than or equal to the argument.

Here's what I think you mean

BigDecimal n = new BigDecimal("1.1111111111111"); n = n.setScale(2, BigDecimal.ROUND_CEILING);

Use the code below. This will give you a string in return with just 2 decimal places.

// Continuing from the code you have on thee link ... 
double Udregning = aValue * EuroTilKroner;
DecimalFormat df = new DecimalFormat("#.00");
String s = df.format(Udregning);
result.setText(s);

Hope this helps else please comment.

Update

As @Oren nicely suggested, you may set the rounding mode as follows:

df.setRoundingMode(RoundingMode.HALF_EVEN);

For more modes see the link.

Since the variables n1, n2 and n3 are ints, their sum and subsequent division are integer as well. As such, the result is truncated to the integer.

To get the accurate result, you should force the division to be a floating-point one. To do this, one of the operands should be a double. You can force this by replacing 3 with 3.0

(n1 + n2 + n3) / 3.0

Next, is how can we round the result to two decimal digits. We can multiply the result by 100, perform the integer division and only then divide by 100 and convert to double.

((n1 + n2 + n3) * 100 / 3) / 100.0

You can see additional ways to round in this question.

Don't use doubles. You can lose some precision. Here's a general purpose function.

public static double round(double unrounded, int precision, int roundingMode)
{
    BigDecimal bd = new BigDecimal(unrounded);
    BigDecimal rounded = bd.setScale(precision, roundingMode);
    return rounded.doubleValue();
}

You can call it with

round(yourNumber, 3, BigDecimal.ROUND_HALF_UP);

"precision" being the number of decimal points you desire.

Math.round(number*100.0)/100.0;

I was working with statistics in Java 2 years ago and I still got the codes of a function that allows you to round a number to the number of decimals that you want. Now you need two, but maybe you would like to try with 3 to compare results, and this function gives you this freedom.

/**
* Round to certain number of decimals
* 
* @param d
* @param decimalPlace
* @return
*/
public static float round(float d, int decimalPlace) {
    BigDecimal bd = new BigDecimal(Float.toString(d));
    bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
    return bd.floatValue();
}

You need to decide if you want to round up or down. In my sample code I am rounding up.

Hope it helps.

EDIT

If you want to preserve the number of decimals when they are zero (I guess it is just for displaying to the user) you just have to change the function type from float to BigDecimal, like this:

public static BigDecimal round(float d, int decimalPlace) {
    BigDecimal bd = new BigDecimal(Float.toString(d));
    bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);       
    return bd;
}

And then call the function this way:

float x = 2.3f;
BigDecimal result;
result=round(x,2);
System.out.println(result);

This will print:

2.30

Well this one works...

double roundOff = Math.round(a * 100.0) / 100.0;

Output is

123.14

Or as @Rufein said

 double roundOff = (double) Math.round(a * 100) / 100;

this will do it for you as well.

Here's an utility that rounds (instead of truncating) a double to specified number of decimal places.

For example:

round(200.3456, 2); // returns 200.35

Original version; watch out with this

public static double round(double value, int places) {
    if (places < 0) throw new IllegalArgumentException();

    long factor = (long) Math.pow(10, places);
    value = value * factor;
    long tmp = Math.round(value);
    return (double) tmp / factor;
}

This breaks down badly in corner cases with either a very high number of decimal places (e.g. round(1000.0d, 17)) or large integer part (e.g. round(90080070060.1d, 9)). Thanks to Sloin for pointing this out.

I've been using the above to round "not-too-big" doubles to 2 or 3 decimal places happily for years (for example to clean up time in seconds for logging purposes: 27.987654321987 -> 27.99). But I guess it's best to avoid it, since more reliable ways are readily available, with cleaner code too.

So, use this instead

(Adapted from this answer by Louis Wasserman and this one by Sean Owen.)

public static double round(double value, int places) {
    if (places < 0) throw new IllegalArgumentException();

    BigDecimal bd = BigDecimal.valueOf(value);
    bd = bd.setScale(places, RoundingMode.HALF_UP);
    return bd.doubleValue();
}

Note that HALF_UP is the rounding mode "commonly taught at school". Peruse the RoundingMode documentation, if you suspect you need something else such as Bankers’ Rounding.

Of course, if you prefer, you can inline the above into a one-liner:
new BigDecimal(value).setScale(places, RoundingMode.HALF_UP).doubleValue()

And in every case

Always remember that floating point representations using float and double are inexact. For example, consider these expressions:

999199.1231231235 == 999199.1231231236 // true
1.03 - 0.41 // 0.6200000000000001

For exactness, you want to use BigDecimal. And while at it, use the constructor that takes a String, never the one taking double. For instance, try executing this:

System.out.println(new BigDecimal(1.03).subtract(new BigDecimal(0.41)));
System.out.println(new BigDecimal("1.03").subtract(new BigDecimal("0.41")));

Some excellent further reading on the topic:

• Item 48: "Avoid float and double if exact answers are required" in Effective Java (2nd ed) by Joshua Bloch
• What Every Programmer Should Know About Floating-Point Arithmetic

If you wanted String formatting instead of (or in addition to) strictly rounding numbers, see the other answers.

Specifically, note that round(200, 0) returns 200.0. If you want to output "200.00", you should first round and then format the result for output (which is perfectly explained in Jesper's answer).