Was ich möchte, ist eine Methode, um ein Double in eine Zeichenfolge umzuwandeln, die mit der Half-Up-Methode rundet. Wenn also die zu rundende Dezimalstelle 5 ist, wird immer auf die nächste Zahl gerundet. Dies ist die Standardmethode zum Runden, die die meisten Menschen in den meisten Situationen erwarten.

Ich möchte auch, dass nur signifikante Ziffern angezeigt werden - dh es sollten keine nachgestellten Nullen vorhanden sein.

Ich weiß, dass eine Methode, dies zu tun, darin besteht, die String.formatMethode zu verwenden:

String.format("%.5g%n", 0.912385);

kehrt zurück:

0.91239

Das ist großartig, zeigt jedoch immer Zahlen mit 5 Dezimalstellen an, auch wenn sie nicht signifikant sind:

String.format("%.5g%n", 0.912300);

kehrt zurück:

0.91230

Eine andere Methode ist die Verwendung von DecimalFormatter:

DecimalFormat df = new DecimalFormat("#.#####");
df.format(0.912385);

kehrt zurück:

0.91238

Wie Sie jedoch sehen können, wird eine halbgleichmäßige Rundung verwendet. Das heißt, es wird abgerundet, wenn die vorherige Ziffer gerade ist. Was ich möchte, ist Folgendes:

0.912385 -> 0.91239
0.912300 -> 0.9123

Was ist der beste Weg, um dies in Java zu erreichen?

Verwenden Sie setRoundingMode, legen Sie die RoundingModeexplizite Einstellung fest , um Ihr Problem mit der halben geraden Runde zu behandeln, und verwenden Sie dann das Formatmuster für die gewünschte Ausgabe.

Beispiel:

DecimalFormat df = new DecimalFormat("#.####");
df.setRoundingMode(RoundingMode.CEILING);
for (Number n : Arrays.asList(12, 123.12345, 0.23, 0.1, 2341234.212431324)) {
    Double d = n.doubleValue();
    System.out.println(df.format(d));
}

gibt die Ausgabe:

12
123.1235
0.23
0.1
2341234.2125

BEARBEITEN : Die ursprüngliche Antwort bezieht sich nicht auf die Genauigkeit der Doppelwerte. Das ist in Ordnung, wenn es Ihnen egal ist, ob es auf- oder abrundet. Wenn Sie jedoch eine genaue Rundung wünschen, müssen Sie die erwartete Genauigkeit der Werte berücksichtigen. Gleitkommawerte haben intern eine binäre Darstellung. Das bedeutet, dass ein Wert wie 2.7735 intern nicht genau diesen Wert hat. Es kann etwas größer oder etwas kleiner sein. Wenn der interne Wert etwas kleiner ist, wird er nicht auf 2,7740 aufgerundet. Um diese Situation zu beheben, müssen Sie sich der Genauigkeit der Werte bewusst sein, mit denen Sie arbeiten, und diesen Wert vor dem Runden addieren oder subtrahieren. Wenn Sie beispielsweise wissen, dass Ihre Werte bis zu 6 Stellen genau sind, addieren Sie diese Genauigkeit zum Wert, um die Werte auf halber Strecke aufzurunden:

Double d = n.doubleValue() + 1e-6;

Subtrahieren Sie zum Abrunden die Genauigkeit.

Unter der Annahme , valueein double, können Sie tun:

(double)Math.round(value * 100000d) / 100000d

Das entspricht einer Genauigkeit von 5 Stellen. Die Anzahl der Nullen gibt die Anzahl der Dezimalstellen an.

new BigDecimal(String.valueOf(double)).setScale(yourScale, BigDecimal.ROUND_HALF_UP);

bekommst du ein BigDecimal. Um die Zeichenfolge aus ihm heraus, rufen Sie einfach , dass BigDecimal‚s toStringMethode oder das toPlainStringVerfahren für Java 5+ für ein einfaches Format - String.

Beispielprogramm:

package trials;
import java.math.BigDecimal;

public class Trials {

    public static void main(String[] args) {
        int yourScale = 10;
        System.out.println(BigDecimal.valueOf(0.42344534534553453453-0.42324534524553453453).setScale(yourScale, BigDecimal.ROUND_HALF_UP));
    }

Sie können auch die verwenden

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

um sicherzustellen, dass Sie die nachgestellten Nullen haben.

Wie einige andere angemerkt haben, ist die richtige Antwort, entweder DecimalFormatoder zu verwenden BigDecimal. Floating-Point nicht hat Dezimalstellen so dass Sie nicht möglicherweise Aufrunden / Abrunden auf eine bestimmte Anzahl von ihnen an erster Stelle. Sie müssen in einem Dezimalradix arbeiten, und genau das tun diese beiden Klassen.

Ich poste den folgenden Code als Gegenbeispiel zu allen Antworten in diesem Thread und in der Tat überall in StackOverflow (und anderswo), die eine Multiplikation gefolgt von einer Kürzung gefolgt von einer Division empfehlen. Befürworter dieser Technik müssen erklären, warum der folgende Code in über 92% der Fälle die falsche Ausgabe erzeugt.

public class RoundingCounterExample
{

    static float roundOff(float x, int position)
    {
        float a = x;
        double temp = Math.pow(10.0, position);
        a *= temp;
        a = Math.round(a);
        return (a / (float)temp);
    }

    public static void main(String[] args)
    {
        float a = roundOff(0.0009434f,3);
        System.out.println("a="+a+" (a % .001)="+(a % 0.001));
        int count = 0, errors = 0;
        for (double x = 0.0; x < 1; x += 0.0001)
        {
            count++;
            double d = x;
            int scale = 2;
            double factor = Math.pow(10, scale);
            d = Math.round(d * factor) / factor;
            if ((d % 0.01) != 0.0)
            {
                System.out.println(d + " " + (d % 0.01));
                errors++;
            }
        }
        System.out.println(count + " trials " + errors + " errors");
    }
}

Ausgabe dieses Programms:

10001 trials 9251 errors

BEARBEITEN: Um einige Kommentare unten anzusprechen, habe ich den Modulteil der Testschleife mit BigDecimalund new MathContext(16)für die Moduloperation wie folgt überarbeitet :

public static void main(String[] args)
{
    int count = 0, errors = 0;
    int scale = 2;
    double factor = Math.pow(10, scale);
    MathContext mc = new MathContext(16, RoundingMode.DOWN);
    for (double x = 0.0; x < 1; x += 0.0001)
    {
        count++;
        double d = x;
        d = Math.round(d * factor) / factor;
        BigDecimal bd = new BigDecimal(d, mc);
        bd = bd.remainder(new BigDecimal("0.01"), mc);
        if (bd.multiply(BigDecimal.valueOf(100)).remainder(BigDecimal.ONE, mc).compareTo(BigDecimal.ZERO) != 0)
        {
            System.out.println(d + " " + bd);
            errors++;
        }
    }
    System.out.println(count + " trials " + errors + " errors");
}

Ergebnis:

10001 trials 4401 errors

Angenommen, Sie haben

double d = 9232.129394d;

Sie können verwenden BigDecimal

BigDecimal bd = new BigDecimal(d).setScale(2, RoundingMode.HALF_EVEN);
d = bd.doubleValue();

oder ohne BigDecimal

d = Math.round(d*100)/100.0d;

mit beiden Lösungen d == 9232.13

Sie können die DecimalFormat-Klasse verwenden.

double d = 3.76628729;

DecimalFormat newFormat = new DecimalFormat("#.##");
double twoDecimal =  Double.valueOf(newFormat.format(d));

In der Java- Anleitung von Real wird diese Lösung veröffentlicht, die auch für Versionen vor Java 1.6 kompatibel ist.

BigDecimal bd = new BigDecimal(Double.toString(d));
bd = bd.setScale(decimalPlace, BigDecimal.ROUND_HALF_UP);
return bd.doubleValue();

double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;

@Milhous: Das Dezimalformat für die Rundung ist ausgezeichnet:

Sie können auch die verwenden

DecimalFormat df = new DecimalFormat("#.00000");
df.format(0.912385);

um sicherzustellen, dass Sie die nachgestellten Nullen haben.

Ich würde hinzufügen, dass diese Methode sehr gut darin ist, einen tatsächlichen numerischen Rundungsmechanismus bereitzustellen - nicht nur visuell, sondern auch bei der Verarbeitung.

Hypothetisch: Sie müssen einen Rundungsmechanismus in ein GUI-Programm implementieren. Um die Genauigkeit / Präzision einer Ergebnisausgabe zu ändern, ändern Sie einfach das Caret-Format (dh innerhalb der Klammern). Damit:

DecimalFormat df = new DecimalFormat("#0.######");
df.format(0.912385);

würde als Ausgabe zurückkehren: 0.912385

DecimalFormat df = new DecimalFormat("#0.#####");
df.format(0.912385);

würde als Ausgabe zurückkehren: 0.91239

DecimalFormat df = new DecimalFormat("#0.####");
df.format(0.912385);

würde als Ausgabe zurückkehren: 0.9124

[BEARBEITEN: Auch wenn das Caret-Format so ist ("# 0. #############") und Sie eine Dezimalzahl eingeben, z. B. 3.1415926, erzeugt DecimalFormat aus Gründen des Arguments keinen Müll ( zB nachgestellte Nullen) und wird zurückgegeben: 3.1415926.. wenn Sie so geneigt sind. Zugegeben, es ist ein wenig ausführlich für den Geschmack einiger Entwickler - aber hey, es hat einen geringen Speicherbedarf während der Verarbeitung und ist sehr einfach zu implementieren.]

Das Schöne an DecimalFormat ist also, dass es gleichzeitig das Erscheinungsbild der Zeichenfolge sowie die eingestellte Rundungsgenauigkeit behandelt. Ergo: Sie erhalten zwei Vorteile zum Preis einer Code-Implementierung. ;)

Hier ist eine Zusammenfassung dessen, was Sie verwenden können, wenn Sie das Ergebnis als String erhalten möchten:

1. DecimalFormat # setRoundingMode () :

   DecimalFormat df = new DecimalFormat("#.#####");
   df.setRoundingMode(RoundingMode.HALF_UP);
   String str1 = df.format(0.912385)); // 0.91239

2. BigDecimal # setScale ()

   String str2 = new BigDecimal(0.912385)
       .setScale(5, BigDecimal.ROUND_HALF_UP)
       .toString();

Hier ist ein Vorschlag, welche Bibliotheken Sie verwenden können, wenn Sie dies möchten double. Ich würde es jedoch nicht für die Zeichenfolgenkonvertierung empfehlen, da double möglicherweise nicht genau das darstellen kann, was Sie möchten (siehe z. B. hier ):

1. Präzision von Apache Commons Math

   double rounded = Precision.round(0.912385, 5, BigDecimal.ROUND_HALF_UP);

2. Funktionen von Colt

   double rounded = Functions.round(0.00001).apply(0.912385)

3. Utils von Weka

   double rounded = Utils.roundDouble(0.912385, 5)

Sie können die folgende Dienstprogrammmethode verwenden:

public static double round(double valueToRound, int numberOfDecimalPlaces)
{
    double multipicationFactor = Math.pow(10, numberOfDecimalPlaces);
    double interestedInZeroDPs = valueToRound * multipicationFactor;
    return Math.round(interestedInZeroDPs) / multipicationFactor;
}

Eine prägnante Lösung:

   public static double round(double value, int precision) {
      int scale = (int) Math.pow(10, precision);
      return (double) Math.round(value * scale) / scale;
  }

Siehe auch https://stackoverflow.com/a/22186845/212950 Vielen Dank an jpdymond für das Angebot.

Sie können BigDecimal verwenden

BigDecimal value = new BigDecimal("2.3");
value = value.setScale(0, RoundingMode.UP);
BigDecimal value1 = new BigDecimal("-2.3");
value1 = value1.setScale(0, RoundingMode.UP);
System.out.println(value + "n" + value1);

Siehe: http://www.javabeat.net/precise-rounding-of-decimals-using-rounding-mode-enumeration/

Versuchen Sie Folgendes: org.apache.commons.math3.util.Precision.round (double x, int scale)

Siehe: http://commons.apache.org/proper/commons-math/apidocs/org/apache/commons/math3/util/Precision.html

Die Homepage der Apache Commons Mathematics Library lautet: http://commons.apache.org/proper/commons-math/index.html

Die interne Implementierung dieser Methode lautet:

public static double round(double x, int scale) {
    return round(x, scale, BigDecimal.ROUND_HALF_UP);
}

public static double round(double x, int scale, int roundingMethod) {
    try {
        return (new BigDecimal
               (Double.toString(x))
               .setScale(scale, roundingMethod))
               .doubleValue();
    } catch (NumberFormatException ex) {
        if (Double.isInfinite(x)) {
            return x;
        } else {
            return Double.NaN;
        }
    }
}

Da ich zu diesem Thema keine vollständige Antwort gefunden habe, habe ich eine Klasse zusammengestellt, die dies richtig handhaben sollte, mit Unterstützung für:

• Formatierung : Formatieren Sie einfach eine doppelte Zeichenfolge mit einer bestimmten Anzahl von Dezimalstellen
• Parsing : Analysiert den formatierten Wert zurück auf double
• Gebietsschema : Formatieren und analysieren Sie das Standardgebietsschema
• Exponentialnotation : Beginnen Sie nach einem bestimmten Schwellenwert mit der Verwendung der Exponentialnotation

Die Verwendung ist ziemlich einfach :

(Für dieses Beispiel verwende ich ein benutzerdefiniertes Gebietsschema.)

public static final int DECIMAL_PLACES = 2;

NumberFormatter formatter = new NumberFormatter(DECIMAL_PLACES);

String value = formatter.format(9.319); // "9,32"
String value2 = formatter.format(0.0000005); // "5,00E-7"
String value3 = formatter.format(1324134123); // "1,32E9"

double parsedValue1 = formatter.parse("0,4E-2", 0); // 0.004
double parsedValue2 = formatter.parse("0,002", 0); // 0.002
double parsedValue3 = formatter.parse("3423,12345", 0); // 3423.12345

Hier ist die Klasse :

import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.text.ParseException;
import java.util.Locale;

public class NumberFormatter {

    private static final String SYMBOL_INFINITE           = "\u221e";
    private static final char   SYMBOL_MINUS              = '-';
    private static final char   SYMBOL_ZERO               = '0';
    private static final int    DECIMAL_LEADING_GROUPS    = 10;
    private static final int    EXPONENTIAL_INT_THRESHOLD = 1000000000; // After this value switch to exponential notation
    private static final double EXPONENTIAL_DEC_THRESHOLD = 0.0001; // Below this value switch to exponential notation

    private DecimalFormat decimalFormat;
    private DecimalFormat decimalFormatLong;
    private DecimalFormat exponentialFormat;

    private char groupSeparator;

    public NumberFormatter(int decimalPlaces) {
        configureDecimalPlaces(decimalPlaces);
    }

    public void configureDecimalPlaces(int decimalPlaces) {
        if (decimalPlaces <= 0) {
            throw new IllegalArgumentException("Invalid decimal places");
        }

        DecimalFormatSymbols separators = new DecimalFormatSymbols(Locale.getDefault());
        separators.setMinusSign(SYMBOL_MINUS);
        separators.setZeroDigit(SYMBOL_ZERO);

        groupSeparator = separators.getGroupingSeparator();

        StringBuilder decimal = new StringBuilder();
        StringBuilder exponential = new StringBuilder("0.");

        for (int i = 0; i < DECIMAL_LEADING_GROUPS; i++) {
            decimal.append("###").append(i == DECIMAL_LEADING_GROUPS - 1 ? "." : ",");
        }

        for (int i = 0; i < decimalPlaces; i++) {
            decimal.append("#");
            exponential.append("0");
        }

        exponential.append("E0");

        decimalFormat = new DecimalFormat(decimal.toString(), separators);
        decimalFormatLong = new DecimalFormat(decimal.append("####").toString(), separators);
        exponentialFormat = new DecimalFormat(exponential.toString(), separators);

        decimalFormat.setRoundingMode(RoundingMode.HALF_UP);
        decimalFormatLong.setRoundingMode(RoundingMode.HALF_UP);
        exponentialFormat.setRoundingMode(RoundingMode.HALF_UP);
    }

    public String format(double value) {
        String result;
        if (Double.isNaN(value)) {
            result = "";
        } else if (Double.isInfinite(value)) {
            result = String.valueOf(SYMBOL_INFINITE);
        } else {
            double absValue = Math.abs(value);
            if (absValue >= 1) {
                if (absValue >= EXPONENTIAL_INT_THRESHOLD) {
                    value = Math.floor(value);
                    result = exponentialFormat.format(value);
                } else {
                    result = decimalFormat.format(value);
                }
            } else if (absValue < 1 && absValue > 0) {
                if (absValue >= EXPONENTIAL_DEC_THRESHOLD) {
                    result = decimalFormat.format(value);
                    if (result.equalsIgnoreCase("0")) {
                        result = decimalFormatLong.format(value);
                    }
                } else {
                    result = exponentialFormat.format(value);
                }
            } else {
                result = "0";
            }
        }
        return result;
    }

    public String formatWithoutGroupSeparators(double value) {
        return removeGroupSeparators(format(value));
    }

    public double parse(String value, double defValue) {
        try {
            return decimalFormat.parse(value).doubleValue();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return defValue;
    }

    private String removeGroupSeparators(String number) {
        return number.replace(String.valueOf(groupSeparator), "");
    }

}

Wenn Sie wirklich Dezimalzahlen für die Berechnung (und nicht nur für die Ausgabe) möchten, verwenden Sie kein binärbasiertes Gleitkommaformat wie double.

Use BigDecimal or any other decimal-based format.

Ich verwende BigDecimal für Berechnungen, aber denke daran, dass es von der Größe der Zahlen abhängt, mit denen du es zu tun hast. In den meisten meiner Implementierungen ist das Parsen von Double oder Integer nach Long für Berechnungen mit sehr großen Zahlen ausreichend.

Tatsächlich habe ich kürzlich Parsed-to-Long verwendet, um genaue Darstellungen (im Gegensatz zu Hex-Ergebnissen) in einer GUI für Zahlen zu erhalten, die so groß sind wie ################### ################ Zeichen (als Beispiel).

Um dies zu erreichen, können wir diesen Formatierer verwenden:

 DecimalFormat df = new DecimalFormat("#.00");
 String resultado = df.format(valor)

oder:

DecimalFormat df = new DecimalFormat("0.00"); :

Verwenden Sie diese Methode, um immer zwei Dezimalstellen zu erhalten:

   private static String getTwoDecimals(double value){
      DecimalFormat df = new DecimalFormat("0.00"); 
      return df.format(value);
    }

Definieren dieser Werte:

91.32
5.22
11.5
1.2
2.6

Mit der Methode können wir diese Ergebnisse erhalten:

91.32
5.22
11.50
1.20
2.60

Demo online.

Nur für den Fall, dass noch jemand Hilfe benötigt. Diese Lösung funktioniert perfekt für mich.

private String withNoTrailingZeros(final double value, final int nrOfDecimals) {
return new BigDecimal(String.valueOf(value)).setScale(nrOfDecimals,  BigDecimal.ROUND_HALF_UP).stripTrailingZeros().toPlainString();

}

gibt a String mit der gewünschten Ausgabe zurück.

Ich stimme der gewählten Antwort zu DecimalFormat--- oder alternativBigDecimal .

Bitte lesen Sie zuerst das Update unten!

Wenn Sie jedoch den doppelten Wert runden und ein doubleWertergebnis erhalten möchten , können Sie ihn org.apache.commons.math3.util.Precision.round(..)wie oben erwähnt verwenden. Die Implementierung verwendet BigDecimal, ist langsam und erzeugt Müll.

Eine ähnliche, aber schnelle und DoubleRoundermüllfreie Methode bietet das Dienstprogramm in der decimal4j-Bibliothek:

 double a = DoubleRounder.round(2.0/3.0, 3);
 double b = DoubleRounder.round(2.0/3.0, 3, RoundingMode.DOWN);
 double c = DoubleRounder.round(1000.0d, 17);
 double d = DoubleRounder.round(90080070060.1d, 9);
 System.out.println(a);
 System.out.println(b);
 System.out.println(c);
 System.out.println(d);

Wird ausgegeben

 0.667
 0.666
 1000.0
 9.00800700601E10

Siehe https://github.com/tools4j/decimal4j/wiki/DoubleRounder-Utility

Haftungsausschluss: Ich bin am decimal4j-Projekt beteiligt.

Update: Wie @iaforek hervorhob, gibt DoubleRounder manchmal kontraintuitive Ergebnisse zurück. Der Grund ist, dass es eine mathematisch korrekte Rundung durchführt. Zum BeispielDoubleRounder.round(256.025d, 2) wird auf 256,02 abgerundet, weil der als 256,025d dargestellte Doppelwert etwas kleiner als der rationale Wert 256,025 ist und daher abgerundet wird.

Anmerkungen:

• Dieses Verhalten ist dem des BigDecimal(double)Konstruktors sehr ähnlich (verwendet jedoch nicht valueOf(double)den String-Konstruktor).
• Das Problem kann zuerst mit einem doppelten Rundungsschritt mit höherer Präzision umgangen werden, aber es ist kompliziert und ich gehe hier nicht auf die Details ein

Aus diesen Gründen und allem, was oben in diesem Beitrag erwähnt wurde, kann ich die Verwendung von DoubleRounder nicht empfehlen .

Das folgende Codefragment zeigt, wie n Ziffern angezeigt werden. Der Trick besteht darin, die Variable pp auf 1 zu setzen, gefolgt von n Nullen. Im folgenden Beispiel hat der variable pp-Wert 5 Nullen, sodass 5 Ziffern angezeigt werden.

double pp = 10000;

double myVal = 22.268699999999967;
String needVal = "22.2687";

double i = (5.0/pp);

String format = "%10.4f";
String getVal = String.format(format,(Math.round((myVal +i)*pp)/pp)-i).trim();

Wenn Sie DecimalFormatzum Konvertieren verwenden double, Stringist dies sehr einfach:

DecimalFormat formatter = new DecimalFormat("0.0##");
formatter.setRoundingMode(RoundingMode.HALF_UP);

double num = 1.234567;
return formatter.format(num);

RoundingModeAbhängig vom gewünschten Verhalten stehen mehrere Aufzählungswerte zur Auswahl.

Ich kam hierher und wollte nur eine einfache Antwort, wie man eine Zahl rundet. Dies ist eine ergänzende Antwort, um dies zu gewährleisten.

So runden Sie eine Zahl in Java

Der häufigste Fall ist zu verwenden Math.round().

Math.round(3.7) // 4

Zahlen werden auf die nächste ganze Zahl gerundet. Ein .5Wert wird aufgerundet. Wenn Sie ein anderes Rundungsverhalten benötigen, können Sie eine der anderen mathematischen Funktionen verwenden. Siehe den Vergleich unten.

runden

Wie oben angegeben, rundet dies auf die nächste ganze Zahl. .5Dezimalstellen runden ab. Diese Methode gibt eine zurück int.

Math.round(3.0); // 3
Math.round(3.1); // 3
Math.round(3.5); // 4
Math.round(3.9); // 4

Math.round(-3.0); // -3
Math.round(-3.1); // -3
Math.round(-3.5); // -3 *** careful here ***
Math.round(-3.9); // -4

Decke

Jeder Dezimalwert wird auf die nächste Ganzzahl aufgerundet. Es geht zur Decke . Diese Methode gibt a zurück double.

Math.ceil(3.0); // 3.0
Math.ceil(3.1); // 4.0
Math.ceil(3.5); // 4.0
Math.ceil(3.9); // 4.0

Math.ceil(-3.0); // -3.0
Math.ceil(-3.1); // -3.0
Math.ceil(-3.5); // -3.0
Math.ceil(-3.9); // -3.0

Fußboden

Jeder Dezimalwert wird auf die nächste Ganzzahl abgerundet. Diese Methode gibt a zurück double.

Math.floor(3.0); // 3.0
Math.floor(3.1); // 3.0
Math.floor(3.5); // 3.0
Math.floor(3.9); // 3.0

Math.floor(-3.0); // -3.0
Math.floor(-3.1); // -4.0
Math.floor(-3.5); // -4.0
Math.floor(-3.9); // -4.0

rint

Dies ähnelt dem Runden in diesen Dezimalwerten, die auf die nächste Ganzzahl gerundet werden. Doch im Gegensatz zu round, .5runden Werte an die gerade ganze Zahl. Diese Methode gibt a zurück double.

Math.rint(3.0); // 3.0
Math.rint(3.1); // 3.0
Math.rint(3.5); // 4.0 ***
Math.rint(3.9); // 4.0
Math.rint(4.5); // 4.0 ***
Math.rint(5.5); // 6.0 ***

Math.rint(-3.0); // -3.0
Math.rint(-3.1); // -3.0
Math.rint(-3.5); // -4.0 ***
Math.rint(-3.9); // -4.0
Math.rint(-4.5); // -4.0 ***
Math.rint(-5.5); // -6.0 ***

Wenn Sie eine Technologie mit einem minimalen JDK verwenden. Hier ist ein Weg ohne Java-Bibliotheken:

double scale = 100000;    
double myVal = 0.912385;
double rounded = (int)((myVal * scale) + 0.5d) / scale;

DecimalFormat ist die beste Art der Ausgabe, aber ich bevorzuge es nicht. Ich mache das immer die ganze Zeit, weil es den doppelten Wert zurückgibt. Ich kann es also mehr als nur ausgeben.

Math.round(selfEvaluate*100000d.0)/100000d.0;

ODER

Math.round(selfEvaluate*100000d.0)*0.00000d1;

Wenn Sie einen großen Dezimalstellenwert benötigen, können Sie stattdessen BigDecimal verwenden. Sowieso .0ist wichtig. Ohne sie ist die Rundung von 0,33333d5 0,33333 und nur 9 Stellen zulässig. Die zweite Funktion ohne .0Probleme mit 0.30000 return 0.30000000000000004.

Hier ist meine Antwort:

double num = 4.898979485566356;
DecimalFormat df = new DecimalFormat("#.##");      
time = Double.valueOf(df.format(num));

System.out.println(num); // 4.89

Nachdem ich die meisten Antworten gelesen hatte, stellte ich fest, dass die meisten nicht präzise sind. Tatsächlich BigDecimalscheint die Verwendung die beste Wahl zu sein. Wenn Sie jedoch nicht verstehen, wie das RoundingModefunktioniert, verlieren Sie unvermeidlich an Präzision. Ich habe das herausgefunden, als ich mit großen Zahlen in einem Projekt gearbeitet habe, und dachte, es könnte anderen helfen, Probleme beim Runden von Zahlen zu haben. Zum Beispiel.

BigDecimal bd = new BigDecimal("1363.2749");
bd = bd.setScale(2, RoundingMode.HALF_UP);
System.out.println(bd.doubleValue());

Sie würden erwarten, 1363.28als Ausgabe zu erhalten, aber Sie werden am Ende mit 1363.27, was nicht erwartet wird, wenn Sie nicht wissen, was das RoundingModetut. Wenn Sie sich also die Oracle-Dokumente ansehen , finden Sie die folgende Beschreibung für RoundingMode.HALF_UP.

Rundungsmodus zum Runden in Richtung "nächster Nachbar", es sei denn, beide Nachbarn sind gleich weit entfernt. In diesem Fall wird aufgerundet.

Als wir das wussten, stellten wir fest, dass wir keine exakte Rundung erhalten, es sei denn, wir möchten in Richtung des nächsten Nachbarn runden . Um eine angemessene Runde zu erreichen, müssten wir also von der n-1Dezimalstelle zu den gewünschten Dezimalstellen schleifen . Zum Beispiel.

private double round(double value, int places) throws IllegalArgumentException {

    if (places < 0) throw new IllegalArgumentException();

    // Cast the number to a String and then separate the decimals.
    String stringValue = Double.toString(value);
    String decimals = stringValue.split("\\.")[1];

    // Round all the way to the desired number.
    BigDecimal bd = new BigDecimal(stringValue);
    for (int i = decimals.length()-1; i >= places; i--) {
        bd = bd.setScale(i, RoundingMode.HALF_UP);
    }

    return bd.doubleValue();
}

Dies wird uns am Ende den erwarteten Output geben, der sein würde 1363.28.

Wobei dp = Dezimalstelle ist und der Wert ein Doppel ist.

    double p = Math.pow(10d, dp);

    double result = Math.round(value * p)/p;

Beachten Sie, dass String.format () und DecimalFormat Zeichenfolgen mit dem Standardgebietsschema erstellen. Sie können also eine formatierte Zahl mit Punkt oder Komma als Trennzeichen zwischen Ganzzahl- und Dezimalteilen schreiben. Um sicherzustellen, dass der gerundete String das gewünschte Format hat, verwenden Sie java.text.NumberFormat wie folgt:

  Locale locale = Locale.ENGLISH;
  NumberFormat nf = NumberFormat.getNumberInstance(locale);
  // for trailing zeros:
  nf.setMinimumFractionDigits(2);
  // round to 2 digits:
  nf.setMaximumFractionDigits(2);

  System.out.println(nf.format(.99));
  System.out.println(nf.format(123.567));
  System.out.println(nf.format(123.0));

Wird in englischer Sprache gedruckt (unabhängig von Ihrer Ländereinstellung): 0,99 123,57 123,00

Das Beispiel stammt von Farenda - wie man Double korrekt in String konvertiert .

Im Allgemeinen erfolgt die Rundung durch Skalierung: round(num / p) * p

/**
 * MidpointRounding away from zero ('arithmetic' rounding)
 * Uses a half-epsilon for correction. (This offsets IEEE-754
 * half-to-even rounding that was applied at the edge cases).
 */
double RoundCorrect(double num, int precision) {
    double c = 0.5 * EPSILON * num;
//  double p = Math.pow(10, precision); //slow
    double p = 1; while (precision--> 0) p *= 10;
    if (num < 0)
        p *= -1;
    return Math.round((num + c) * p) / p;
}

// testing edge cases
RoundCorrect(1.005, 2);   // 1.01 correct
RoundCorrect(2.175, 2);   // 2.18 correct
RoundCorrect(5.015, 2);   // 5.02 correct

RoundCorrect(-1.005, 2);  // -1.01 correct
RoundCorrect(-2.175, 2);  // -2.18 correct
RoundCorrect(-5.015, 2);  // -5.02 correct