webentwicklung-frage-antwort-db.com.de

Wie eine Zahl in Java auf n Dezimalstellen gerundet wird

Was ich möchte, ist eine Methode, um ein Double in einen String zu konvertieren, der mit der Half-Up-Methode rundet - d. H. Wenn die zu rundende Dezimalstelle 5 ist, wird immer auf die vorherige 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 - d. H. Es sollten keine nachgestellten Nullen vorhanden sein.

Ich weiß, dass eine Methode dafür die String.format -Methode ist:

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

kehrt zurück:

0.91239

das ist großartig, aber es zeigt immer Zahlen mit 5 Dezimalstellen an, auch wenn diese 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, verwendet dies eine halbgerade Rundung. Das heißt, es wird abgerundet, wenn die vorherige Ziffer gerade ist. Was ich gerne hätte, ist Folgendes:

0.912385 -> 0.91239
0.912300 -> 0.9123

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

1175
Alex Spurling

Verwenden Sie setRoundingMode , setzen Sie RoundingMode explizit, 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 aus:

12
123.1235
0.23
0.1
2341234.2125
706
curtisk

Angenommen, value ist ein double, können Sie Folgendes tun:

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

Das ist eine 5-stellige Genauigkeit. Die Anzahl der Nullen gibt die Anzahl der Dezimalstellen an.

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

erhalten Sie eine BigDecimal. Um die Zeichenfolge zu entfernen, rufen Sie einfach die BigDecimal-Methode toString oder die toPlainString-Methode für Java 5+ für eine Zeichenfolge im einfachen Format auf.

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));
    }
183
MetroidFan2002

Sie können auch die

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

um sicherzustellen, dass Sie die nachgestellten Nullen haben.

109
Milhous

Wie einige andere angemerkt haben, ist die richtige Antwort, entweder DecimalFormat oder BigDecimal zu verwenden. Gleitkommazahlen haben keine Dezimalstellen, so dass Sie möglicherweise gar nicht erst auf eine bestimmte Anzahl runden/kürzen können. Sie müssen in einer Dezimalzahl 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 über StackOverflow (und anderswo), die eine Multiplikation mit anschließender Kürzung und anschließender 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 der folgenden Kommentare anzusprechen, habe ich den Modul-Teil der Testschleife mit BigDecimal und new MathContext(16) für die Modul-Operation 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
79
user207421

Angenommen, Sie haben

double d = 9232.129394d;

sie können BigDecimal verwenden

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

77
user593581

Sie können die DecimalFormat-Klasse verwenden.

double d = 3.76628729;

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

Real's Java How-to posts diese Lösung, 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();
36
Ovesh
double myNum = .912385;
int precision = 10000; //keep 4 digits
myNum= Math.floor(myNum * precision +.5)/precision;
32
Chris Cudmore

@Milhous: Das Dezimalformat für das Runden ist ausgezeichnet:

Sie können auch die

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

um sicherzustellen, dass Sie die nachgestellten Nullen haben.

Ich möchte hinzufügen, dass diese Methode sehr gut ist, um 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 einer Ergebnisausgabe zu ändern, ändern Sie einfach das Caret-Format (d. H. 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. 3.1415926, um des Arguments willen, erzeugt DecimalFormat keinen Müll (z. B. nachgestellte Nullen) und gibt Folgendes zurück: 3.1415926 .., wenn Sie so geneigt sind. Zugegeben, es ist ein wenig wortreich 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 im Wesentlichen, dass es gleichzeitig das Erscheinungsbild der Zeichenfolge sowie den Grad der eingestellten Rundungsgenauigkeit berücksichtigt. Ergo: Sie erhalten zwei Vorteile zum Preis einer Code-Implementierung. ;)

29
Ivan

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;
}
18
Amit

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 als Ergebnis double möchten. Ich würde es jedoch nicht für die String-Konvertierung empfehlen, da double möglicherweise nicht in der Lage ist, genau das darzustellen, was Sie wollen (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. tils von Weka

    double rounded = Utils.roundDouble(0.912385, 5)
    
16
Mifeet

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/21295 Vielen Dank an jpdymond für das Angebot.

10
MAbraham1

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/

9

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 ist:

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;
        }
    }
}
7
Li Ying

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

  • Formatierung: Einfaches Formatieren eines Double in eine Zeichenfolge mit einer bestimmten Anzahl von Dezimalstellen
  • Parsing: Analysiert den formatierten Wert zurück, um ihn zu verdoppeln
  • Gebietsschema: Formatieren und analysieren Sie mit dem Standardgebietsschema
  • Exponentialnotation: Verwenden Sie die Exponentialnotation ab einem bestimmten Schwellenwert

Die Benutzung ist ziemlich einfach:

(In diesem 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), "");
    }

}
6
Andrei Lupsa

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

Use BigDecimal or any other decimal-based format.

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

Tatsächlich habe ich kürzlich Parsed-to-Long verwendet, um genaue Darstellungen (im Gegensatz zu Hex-Ergebnissen) in einer GUI für Zahlen mit einer Größe von ################# zu erhalten. ################ Zeichen (als Beispiel).

6
Ivan

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 ein String mit der gewünschten Ausgabe zurück.

4
Asher Oloo

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);
    }

Diese Werte definieren:

91.32
5.22
11.5
1.2
2.6

Mit der Methode können wir folgende Ergebnisse erzielen:

91.32
5.22
11.50
1.20
2.60

Demo online.

3
Jorgesys

Wenn Sie DecimalFormat zum Konvertieren von double in String verwenden, ist dies sehr einfach:

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

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

Abhängig vom gewünschten Verhalten können Sie aus mehreren RoundingMode Aufzählungswerten auswählen.

3
Drew Noakes

Ich bin mit der gewählten Antwort einverstanden, DecimalFormat --- oder alternativ BigDecimal zu verwenden.

Bitte lesen Sie zuerst Update !

Wenn Sie jedoch den doppelten Wert runden und ein Ergebnis von double erhalten möchten, können Sie 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 müllfreie Methode bietet das Hilfsprogramm DoubleRounder in der Bibliothek decimal4j:

 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 betonte, liefert DoubleRounder manchmal unerklärliche Ergebnisse. Der Grund dafür ist, dass die Rundung mathematisch korrekt ist. Zum Beispiel wird DoubleRounder.round(256.025d, 2) auf 256.02 abgerundet, da der als 256.025d dargestellte doppelte Wert etwas kleiner als der rationale Wert 256.025 ist und daher abgerundet wird.

Anmerkungen:

  • Dieses Verhalten ist dem des Konstruktors BigDecimal(double) sehr ähnlich (jedoch nicht dem von valueOf(double), der den Zeichenfolgenkonstruktor verwendet).
  • Das Problem kann umgangen werden, indem zunächst ein doppelter Rundungsschritt mit höherer Genauigkeit ausgeführt wird. Es ist jedoch kompliziert, und ich gehe hier nicht auf die Details ein

Aus diesen Gründen und aus allen oben genannten Gründen kann ich die Verwendung von DoubleRounder nicht empfehlen.

3
marco

Das folgende Code-Snippet 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 die Variable pp value 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();
3
Jasdeep Singh

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.

Wie man eine Zahl in Java rundet

Am häufigsten wird Math.round() verwendet.

Math.round(3.7) // 4

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

rund

Wie oben angegeben, wird auf die nächste ganze Zahl gerundet. .5 Dezimalstellen werden aufgerundet. Diese Methode gibt ein int zurück.

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

ceil

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

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

Etage

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

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 ist vergleichbar mit dem Runden von Dezimalwerten auf die nächste Ganzzahl. Im Gegensatz zu round werden .5 Werte auf die gerade Ganzzahl gerundet. Diese Methode gibt ein double zurück.

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 ***
3
Suragch

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;
2
Craigo

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. So kann ich es mehr als nur ausgeben.

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

OR

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

Wenn Sie einen Wert mit großen Dezimalstellen benötigen, können Sie stattdessen BigDecimal verwenden. Trotzdem ist .0 wichtig. Ohne diesen Parameter ergibt die Rundung von 0.33333d5 den Wert 0.33333 und es sind nur 9 Stellen zulässig. Die zweite Funktion ohne .0 hat Probleme mit der 0,30000-Rückgabe 0,30000000000000004.

1
Se Song

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
0
Amr Ali

Wenn Sie 5 oder n Anzahl der Dezimalstellen berücksichtigen. Vielleicht löst diese Antwort Ihr Problem.

    double a = 123.00449;
    double roundOff1 = Math.round(a*10000)/10000.00;
    double roundOff2 = Math.round(roundOff1*1000)/1000.00;
    double roundOff = Math.round(roundOff2*100)/100.00;

    System.out.println("result:"+roundOff);

Ausgabe wird sein: 123.0 1
Dies kann mit Schleifen- und rekursiven Funktionen gelöst werden.

0
Qamar

hier ist meine Antwort:

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

System.out.println(num); // 4.89
0
Jamal Uddin

Beachten Sie, dass String.format () und DecimalFormat Zeichenfolgen mit dem Standardgebietsschema erzeugen. So können sie formatierte Zahlen mit Punkt oder Komma als Trennzeichen zwischen ganzzahligen und dezimalen Teilen 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 (egal welches Gebietsschema Sie verwenden): 0,99 123,57 123,00

Das Beispiel stammt aus Farenda - wie man double korrekt in String konvertiert .

0
pwojnowski

Wobei dp = die gewünschte Dezimalstelle und Wert ein Double ist.

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

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