Wie kann ich in Java eine doppelte auf zwei Dezimalstellen runden?

Einfach verwenden: (einfach wie pie)

double number = 651.5176515121351;

number = Math.round(number * 100);
number = number/100;

Die Ausgabe wird 651.52 sein

Verwenden Sie einen Ziffernplatzhalter (0), da bei '#' nachfolgende/führende Nullen als nicht vorhanden angezeigt werden: 

DecimalFormat twoDForm = new DecimalFormat("#.00");

Sie können nicht 'ein Doppel auf [beliebige Anzahl von Dezimalstellen "runden, da Doppelpunkte keine Dezimalstellen haben. Sie können einen Double-String in einen Base-10-String mit N Dezimalstellen konvertieren, da Base-10 Dezimalstellen hat. Wenn Sie ihn jedoch zurückkonvertieren, befinden Sie sich wieder im Double-Land mit binary fraktionellen Stellen.

Benutze das 

String.format ("%. 2f", doubleValue) // Änderung 2 entsprechend Ihrer Anforderung.

Dies ist das einfachste, was ich machen könnte, aber es macht die Arbeit viel einfacher als die meisten Beispiele, die ich gesehen habe.

    double total = 1.4563;

    total = Math.round(total * 100);

    System.out.println(total / 100);

Das Ergebnis ist 1.46.

Sie können org.Apache.commons.math.util.MathUtils von Apache common verwenden

double round = MathUtils.round(double1, 2, BigDecimal.ROUND_HALF_DOWN);

Sie können Apache Commons Math verwenden:

Precision.round(double x, int scale)

source: http://commons.Apache.org/proper/commons-math/apidocs/org/Apache/commons/math3/util/Precision.html#round(double,%20int)

doppelter Betrag = 25,00;

NumberFormat-Formatierungsprogramm = new DecimalFormat ("# 0.00");

System.out.println (formatter.format (Betrag));

DecimalFormat df = new DecimalFormat("###.##");
double total = Double.valueOf(val);

Ihre Money-Klasse kann als Unterklasse von Long dargestellt werden oder ein Mitglied, das den Geldwert als native Long darstellt. Wenn Sie dann Ihren Geld-Instantiierungen Werte zuweisen, werden Sie immer Werte speichern, bei denen es sich um echte Geldwerte handelt. Sie geben einfach Ihr Money-Objekt (über Ihre überschriebene toString () - Methode) mit der entsprechenden Formatierung aus. Beispiel: 1,25 US-Dollar in der internen Darstellung eines Money-Objekts beträgt 125. Sie repräsentieren das Geld als Cent oder Pence oder wie auch immer die Mindestbezeichnung in der Währung ist, mit der Sie versiegeln, und dann bei der Ausgabe formatiert wird. Nein, Sie können NIEMALS einen "illegalen" Geldwert speichern, wie zum Beispiel 1,257 USD.

Deklarieren Sie zuerst ein Objekt der Klasse DecimalFormat. Beachten Sie, dass das Argument in der DecimalFormat#.00 ist, was genau 2 Dezimalstellen der Rundung bedeutet.

private static DecimalFormat df2 = new DecimalFormat("#.00");

Wenden Sie jetzt das Format auf Ihren doppelten Wert an:

double input = 32.123456;
System.out.println("double : " + df2.format(input)); // Output: 32.12

Hinweis bei double input = 32.1;

Die Ausgabe wäre dann 32.10 und so weiter.

Hier ist ein einfacher Weg, um die Ausgabe von myFixedNumber auf zwei Dezimalstellen zu gewährleisten:

import Java.text.DecimalFormat;

public class TwoDecimalPlaces {
    static double myFixedNumber = 98765.4321;
    public static void main(String[] args) {

        System.out.println(new DecimalFormat("0.00").format(myFixedNumber));
    }
}

Das Ergebnis ist:98765.43

Wenn das Ergebnis zwei Dezimalstellen haben soll, können Sie dies tun

// assuming you want to round to Infinity.
double tip = (long) (amount * percent + 0.5) / 100.0; 

Dieses Ergebnis ist nicht genau, aber Double.toString (double) korrigiert dies und gibt eine bis zwei Dezimalstellen aus. Sobald Sie jedoch eine andere Berechnung durchführen, erhalten Sie ein Ergebnis, das nicht implizit gerundet wird. ;)

wobei num die doppelte Zahl ist

• Integer 2 bezeichnet die Anzahl der Dezimalstellen, die wir drucken möchten.

• Hier nehmen wir 2 Dezimalvorräte 

  System.out.printf ("%. 2f", num);

Sie können diese Funktion verwenden.

import org.Apache.commons.lang.StringUtils;
public static double roundToDecimals(double number, int c)
{
    String rightPad = StringUtils.rightPad("1", c+1, "0");
    int decimalPoint = Integer.parseInt(rightPad);
    number = Math.round(number * decimalPoint);
    return number/decimalPoint;
}

Ab Java 1.8 können Sie mit Lambda-Ausdrücken und Nullprüfungen mehr tun. Darüber hinaus kann man mit Float oder Double und einer variablen Anzahl von Dezimalstellen umgehen (einschließlich 2 :-)).

public static Double round(Number src, int decimalPlaces) {

    return Optional.ofNullable(src)
            .map(Number::doubleValue)
            .map(BigDecimal::new)
            .map(dbl -> dbl.setScale(decimalPlaces, BigDecimal.ROUND_HALF_UP))
            .map(BigDecimal::doubleValue)
            .orElse(null);
}

    int i = 180;
    int j = 1;
    double div=  ((double)(j*100)/i);
    DecimalFormat df = new DecimalFormat("#.00"); // simple way to format till any deciaml points
    System.out.println(div);
    System.out.println(df.format(div));

Vorausgesetzt, der Betrag kann sowohl positiv als auch negativ sein, kann bei der Rundung auf zwei Dezimalstellen der folgende Code-Snippet verwendet werden.

amount = roundTwoDecimals(amount);

public double roundTwoDecimals(double d) {
    if (d < 0)
       d -= 0.005;
    else if (d > 0)
       d += 0.005;
    return (double)((long)(d * 100.0))/100);
}

Math.round ist eine Antwort, 

public class Util {
 public static Double formatDouble(Double valueToFormat) {
    long rounded = Math.round(valueToFormat*100);
    return rounded/100.0;
 }
}

Testen Sie in Spock, Groovy 

void "test double format"(){
    given:
         Double performance = 0.6666666666666666
    when:
        Double formattedPerformance = Util.formatDouble(performance)
        println "######################## formatted ######################### => ${formattedPerformance}"
    then:
        0.67 == formattedPerformance

}

Sie können dieses probieren:

public static String getRoundedValue(Double value, String format) {
    DecimalFormat df;
    if(format == null)
        df = new DecimalFormat("#.00");
    else 
        df = new DecimalFormat(format);
    return df.format(value);
}

oder

public static double roundDoubleValue(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;
}